updated state fix (#181)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.dockerignore

@@ -1,4 +1,4 @@
-backend/database.db
+backend/**.db
 backend/vendor/**
 frontend/dist/**
 frontend/node_modules/**

.github/CODEOWNERS

@@ -1,5 +0,0 @@
-# These owners will be the default owners for everything in the repo.
-# Unless a later match takes precedence, @o1egl will be requested for
-# review when someone opens a pull request.
-
-*       @o1egl

.github/workflows/main.yaml

@@ -1,100 +1,43 @@
-name: main
+name: main job
 
 on:
   push:
     branches:
-      - 'master'
-    tags:
-      - 'v*'
-  pull_request:
+      - "main"
 
 jobs:
-# linters
-  lint-frontend:
+  push_latest_to_registry:
+    name: Push latest
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '16'
-      - run: make lint-frontend
-  lint-backend:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-go@v2
-        with:
-          go-version: 1.20.1
-      - run: make lint-backend
-  lint-commits:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '16'
-      - run: make lint-commits
-  lint:
-    runs-on: ubuntu-latest
-    needs: [lint-frontend, lint-backend, lint-commits]
-    steps:
-      - run: echo "done"
-
-# tests
-  test-frontend:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '16'
-      - run: make test-frontend
-  test-backend:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-go@v2
-        with:
-          go-version: 1.20.1
-      - run: make test-backend
-  test:
-    runs-on: ubuntu-latest
-    needs: [test-frontend, test-backend]
-    steps:
-      - run: echo "done"
-
-# release
-  release:
-    runs-on: ubuntu-latest
-    needs: [lint, test]
-    if: startsWith(github.event.ref, 'refs/tags/v')
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-go@v2
-        with:
-          go-version: 1.20.1
-      - uses: actions/setup-node@v2
-        with:
-          node-version: '16'
+      - name: Checkout
+        uses: actions/checkout@v4
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
+        uses: docker/setup-qemu-action@v3.0.0
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-      - name: Build frontend
-        run: make build-frontend
+        uses: docker/setup-buildx-action@v3.0.0
+        # Workaround to fix error:
+        # failed to push: failed to copy: io: read/write on closed pipe
+        # See https://github.com/docker/build-push-action/issues/761
+        with:
+          driver-opts: |
+            image=moby/buildkit:v0.10.6
       - name: Login to Docker Hub
-        uses: docker/login-action@v1
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v2
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
         with:
-          version: latest
-          args: release --rm-dist
-        env:
-          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
+          images: gtstef/filebrowser
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          file: ./Dockerfile
+          push: true
+          tags: 'gtstef/filebrowser:latest'
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/pr.yaml

@@ -0,0 +1,44 @@
+name: pr-merge
+
+on:
+  pull_request:
+    branches:
+      - "main"
+      - "v[0-9]+.[0-9]+.[0-9]+"
+      - "dev_*"
+
+jobs:
+  push_pr_to_registry:
+    name: Push PR
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.0.0
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.0.0
+        # Workaround to fix error:
+        # failed to push: failed to copy: io: read/write on closed pipe
+        # See https://github.com/docker/build-push-action/issues/761
+        with:
+          driver-opts: |
+            image=moby/buildkit:v0.10.6
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: gtstef/filebrowser
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/regular-tests.yaml

@@ -0,0 +1,44 @@
+name: dev
+
+on:
+  push:
+    branches:
+      - "*"
+
+jobs:
+  test-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: 'stable'
+      - working-directory: backend
+        run: go test -race -v ./...
+  lint-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+            go-version: 'stable'
+      - uses: golangci/golangci-lint-action@v6
+        with:
+          version: v1.59
+          working-directory: backend
+  format-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: 'stable'
+      - working-directory: backend
+        run: go fmt ./...
+  lint-frontend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+      - working-directory: frontend
+        run: npm i eslint && npm run lint

.github/workflows/release.yaml

@@ -0,0 +1,79 @@
+name: release
+
+on:
+  push:
+    branches:
+      - "v[0-9]+.[0-9]+.[0-9]+"
+
+permissions:
+  contents: write
+
+jobs:
+  create_release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.PAT }}
+      - name: Extract branch name
+        shell: bash
+        run: echo "branch=${GITHUB_HEAD_REF:-${GITHUB_REF#refs/heads/}}" >> $GITHUB_OUTPUT
+        id: extract_branch
+      - uses: actions/setup-go@v5
+        with:
+          go-version: 1.22.2
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          target_commitish: ${{ steps.extract_branch.outputs.branch }}
+          token: ${{ secrets.PAT }}
+          tag_name: ${{ steps.extract_branch.outputs.branch }}
+          prerelease: false
+          draft: false
+          generate_release_notes: true
+          name: ${{ steps.extract_branch.outputs.branch }}
+  push_release_to_registry:
+    name: Push release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3.0.0
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3.0.0
+        # Workaround to fix error:
+        # failed to push: failed to copy: io: read/write on closed pipe
+        # See https://github.com/docker/build-push-action/issues/761
+        with:
+          driver-opts: |
+            image=moby/buildkit:v0.10.6
+      - name: Login to Docker Hub
+        # Only push to Docker Hub when making a release
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: gtstef/filebrowser
+      - name: Strip v from version number
+        id: modify-json
+        run: |
+          JSON="${{ steps.meta.outputs.tags }}"
+          # Use jq to remove 'v' from the version field
+          JSON=$(echo "$JSON" | sed 's/filebrowser:v/filebrowser:/')
+          echo "cleaned_tag=$JSON" >> $GITHUB_OUTPUT
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          file: ./Dockerfile
+          push: true
+          tags: ${{ steps.modify-json.outputs.cleaned_tag }}
+          labels: ${{ steps.meta.outputs.labels }}

.github/workflows/stale.yaml

@@ -16,9 +16,9 @@ jobs:
           stale-pr-message: 'This PR is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
           close-pr-message: 'This PR was closed because it has been stalled for 5 days with no activity.'
           stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 5 days.'
-          close-issue-message: 'This issue was closed because it has been stalled for 5 days with no activity.'
+          close-issue-message: 'This issue was closed because it has been stalled for 30 days with no activity.'
           days-before-stale: 30
-          days-before-close: 5
+          days-before-close: 30
           exempt-issue-labels: 'feature ☘,enhancement ⚙,bug 🐞'
           exempt-pr-labels: 'need-help,wip'
           operations-per-run: 100

.github/workflows/tag.yaml

@@ -0,0 +1,31 @@
+name: tag
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  update_tag:
+    name: Update Release tag
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+      - name: Install dependencies and build frontend
+        run: npm i && npm run build
+        working-directory: frontend
+      - name: Install UPX
+        run: sudo apt-get install -y upx
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v6
+        with:
+          args: release --clean
+          workdir: backend
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -6,8 +6,11 @@ rice-box.go
 /filebrowser
 /filebrowser.exe
 /frontend/dist
+/frontend/pkg
+/frontend/package-lock.json
 /backend/vendor
 /backend/*.cov
+/backend/test_config.yaml
 
 .DS_Store
 node_modules

CHANGELOG.md

@@ -1,45 +1,135 @@
 # Changelog
 
-All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+All notable changes to this project will be documented in this file. For commit guidelines, please refer to [Standard Version](https://github.com/conventional-changelog/standard-version).
 
-# v0.1.4
- - various UI fixes
-   - Added download button back to toolbar
-   - Added upload button to side menu
-   - breadcrumb spacing fix
-   - Added "compact" view option
-   - fixed slash issue with css rtl logic
- - various backend fixes
-   - search has a sessionId attached so searches don't collide
-   - search no longer searches by word with spaces, includes space in searches
-   - prepared for full json configuration
- - made size search work for smaller and larger
- - made search types not show up in search bar when used
+## v0.2.7
+
+ - **Change**: New sidebar style and behavior
+ - **Change**: make search view and button behavior more consistent.
+ - **Fix**: [upload file bug](https://github.com/gtsteffaniak/filebrowser/issues/153)
+ - **Fix**: user lock out bug introduced in 0.2.6
+ - **Fix**: many minor state related issues.
+
+## v0.2.6
+
+This change focuses on minimizing and simplifying build process.
+
+- **Change**: Migrated to Vite / Vue 3
+- **Change**: removed npm modules
+  - replaced vuex with custom state management via src/store
+  - replaced noty with simple card popup notifications
+  - replaced moment with simple date formatter where needed
+  - replaced vue-simple-progress with vue component
+- **Feature**: improved error logging
+  - backend errors show the root function that called them during the error
+  - frontend errors print errors to console that fail try/catch
+  - all frontend errors via popup notification & print to console as well
+- **Fix**: Allow editing blank text based files in editor
+- tweaked listing styles
+- Feature: Allow disabling the index via configuration yaml
+
+## v0.2.5
+
+- Fix: delete user prompt works using native hovers.
+
+## v0.2.4
+
+- Feature: [create-folder-feature](https://github.com/gtsteffaniak/filebrowser/pull/105)
+- Feature: [playable shared video](https://github.com/filebrowser/filebrowser/issues/2537)
+- Feature: photos, videos, and audio get embedded preview on share instead of icon
+- Fix: sharable link bug, now uses special publicUser
+- Bump go version to 1.22
+- In prep for vue3 migration, npm modules removed:
+  - js-base64
+  - pretty-bytes
+  - whatwg-fetch
+  - lodash.throttle
+  - lodash.clonedeep
+
+## v0.2.3
+
+- Feature: token expiration time now configurable
+- FIX: Hidden files are still directly accessible. (https://github.com/filebrowser/filebrowser/issues/2698)
+- FIX: search/user context bug
+
+## v0.2.2
+
+- CHG: **Speed:** (0m57s) - Decreased by 78% compared to the previous release.
+- CHG: **Memory Usage:** (41MB) - Reduced by 45% compared to the previous release.
+- Feature: Now utilizes the index for file browser listings!
+- FIX: Editor issues fixed on save and themes.
+
+## v0.2.1
+
+- Addressed issue #29 - Rules can now be configured and read from the configuration YAML.
+- Addressed issue #28 - Allows disabling settings per user.
+- Addressed issue #27 - Shortened download link for password-protected files.
+- Addressed issue #26 - Enables dark mode per user and improves switching performance.
+- Improved styling with more rounded corners and enhanced listing design.
+- Enhanced search performance.
+- Fixed authentication issues.
+- Added compact view mode.
+- Improved view mode configuration and behavior.
+- Updated the configuration file to accept new settings.
+
+## v0.2.0
+
+- **Improved UI:**
+  - Enhanced the cohesive and unified look.
+  - Adjusted the header bar appearance and icon behavior.
+- The shell feature has been deprecated.
+  - Custom commands can be executed within the Docker container if needed.
+- The JSON config file is no longer used.
+  - All configurations are now performed via the advanced `filebrowser.yaml`.
+  - The only allowed flag is specifying the config file.
+- Removed old code for migrating database versions.
+- Eliminated all unused `cmd` code.
+
+## v0.1.4
+
+- **Various UI fixes:**
+  - Reintroduced the download button to the toolbar.
+  - Added the upload button to the side menu.
+  - Adjusted breadcrumb spacing.
+  - Introduced a "compact" view option.
+  - Fixed a slash issue with CSS right-to-left (RTL) logic.
+- **Various backend improvements:**
+  - Added session IDs to searches to prevent collisions.
+  - Modified search behavior to include spaces in searches.
+  - Prepared for full JSON configuration support.
+- Made size-based searches work for both smaller and larger files.
+- Modified search types not to appear in the search bar when used.
 
 ## v0.1.3
 
- - improved styling, colors, transparency, blur
- - Made sidebar hidden on desktop as well
- - simplified navbar to be three buttons
-   - open menu
-   - search
-   - toggle view
- - Changed desktop search style and included additional search options.
+- Enhanced styling with improved colors, transparency, and blur effects.
+- Hid the sidebar on desktop views.
+- Simplified the navbar to include three buttons:
+  - Open menu
+  - Search
+  - Toggle view
+- Revised desktop search style and included additional search options.
 
 ## v0.1.2
 
- - Updated UI to use search features better
-   - More filter options
-   - Better icons with colors
-   - GUI styling
- - Improved search performance
+- Updated the UI to better utilize search features:
+  - Added more filter options.
+  - Enhanced icons with colors.
+  - Improved GUI styling.
+- Improved search performance.
+- **Index Changes:**
+  - **Speed:** (0m32s) - Increased by 6% compared to the previous release.
+  - **Memory Usage:** (93MB) - Increased by 3% compared to the previous release.
 
 ## v0.1.1
 
- - Improved search with indexing
+- Improved search functionality with indexing.
+- **Index Changes (Baseline Results):**
+  - **Speed:** (0m30s)
+  - **Memory Usage:** (90MB)
 
 ## v0.1.0
 
- - nothing changed from origin.
+- No changes from the original.
 
-Forked from https://github.com/filebrowser/filebrowser
+Forked from [filebrowser/filebrowser](https://github.com/filebrowser/filebrowser).

Dockerfile

@@ -1,23 +1,19 @@
 FROM node:slim as nbuild
 WORKDIR /app
-COPY  ./frontend/package*.json ./
-RUN npm i
+COPY ./frontend/package*.json ./
+RUN npm i --maxsockets 1
 COPY  ./frontend/ ./
-RUN npm run build
+RUN npm run build-docker
 
-FROM golang:1.21-alpine as base
+FROM golang:1.22-alpine as base
 WORKDIR /app
-COPY  ./backend ./
+COPY ./backend ./
 RUN go build -ldflags="-w -s" -o filebrowser .
 
 FROM alpine:latest
-RUN apk --no-cache add \
-      ca-certificates \
-      mailcap
-VOLUME /srv
-EXPOSE 8080
-WORKDIR /
-COPY --from=base /app/.filebrowser.json /.filebrowser.json
-COPY --from=base /app/filebrowser /filebrowser
-COPY --from=nbuild /app/dist/ /frontend/dist/
-ENTRYPOINT [ "./filebrowser" ]
+ENV FILEBROWSER_NO_EMBEDED="true"
+ARG app="/app/filebrowser"
+RUN apk --no-cache add ca-certificates mailcap
+COPY --from=base /app/filebrowser* ./
+COPY --from=nbuild /app/dist/ ./frontend/dist/
+ENTRYPOINT [ "./filebrowser" ]

README.md

@@ -1,87 +1,84 @@
-## Filebrowser
+<p align="center">
+  <a href="https://opensource.org/license/apache-2-0/"><img src="https://img.shields.io/badge/License-Apache_2.0-blue.svg" alt="License: Apache-2.0"></a>
+</p>
+<p align="center">
+  <img src="frontend/public/img/icons/favicon-256x256.png" width="100" title="Login With Custom URL">
+</p>
+<h3 align="center">Filebrowser - A modern web-based file manager</h3>
+<p align="center">
+  <img width="800" src="https://github.com/user-attachments/assets/8ba93582-aba2-4996-8ac3-25f763a2e596" title="Main Screenshot">
+</p>
 
-**Note: Intended to be used in docker only.**
+> [!WARNING]
+> Starting with v0.2.0, *ALL* configuration is done via `filebrowser.yaml`
+> Configuration file.
+> Starting with v0.2.4 *ALL* share links need to be re-created (due to
+> security fix).
 
-This fork makes the following significant changes to filebrowser for origin:
+This fork makes the following significant changes to filebrowser for
+origin:
 
- 1. [x] Improves search to use index instead of filesystem.
-    - [x] Lightning fast
-    - [x] Realtime results as you type
-    - [x] Works with file type filter
-    - [x] better desktop search view
- 1. [ ] Preview enhancements
-    - Preview default view is constrained to files subwindow,
-    which can be toggled to fullscreen.
- 1. [x] Improved and simplified GUI
-    - Moved all action buttons to file action bar except for switch-view
-    - Simplified navbar to 3 main actions: settings,search, and switch-view
-    - New search view on desktop
- 1. [x] Updated version and dependencies
-    - [x] Uses latest npm and node version
-    - [x] Removes deprecated npm packages
-    - [x] Updates golang dependencies
-    - [ ] Remove all unnecessary packages, replaces with generic functions.
- 1. [ ] Moved all configurations to filebrowser.json.
-  no more flags or binary operations to db
- 1. [ ] File browsing uses index first for better performance
-    - file details shown only when toggled or needed
+  1. [x] Better search
+     - Lightning fast
+     - real-time results as you type
+     - Works with more type filters
+     - interactive results page.
+  2. [x] Revamped and simplified GUI navbar and sidebar menu.
+     - Additional compact view mode as well as refreshed view mode
+       styles.
+  3. [x] Revamped configuration via `filebrowser.yml` config file.
+     - More configurations possible at a per-user level
 
 ## About
 
 Filebrowser provides a file managing interface within a specified directory
-and it can be used to upload, delete, preview, rename and edit your files.
-It allows the creation of multiple users and each user can have its own
-directory. It can be used as a standalone app.
+and can be used to upload, delete, preview, rename, and edit your files.
+It allows the creation of multiple users and each user can have its 
+directory.
 
 This repository is a fork, a collection of changes that make this program
-work better in terms of asthetics and performance. Improved search,
- simplified ui (without removing features) and more secure and up-to-date
- build are just a few examples.
+work better in terms of aesthetics and performance. Improved search,
+simplified ui (without removing features) and more secure and up-to-date
+build are just a few examples.
 
-There are a few more changes needed to get it to a stable status where it
-will only recieve security updates. These changes are mentioned above.
-Once this is fully complete, the only updates to th
+This Implementation of filebrowser differs significantly to the original.
+There are hundreds of thousands of lines changed and they are generally
+no longer compatible with each other. This has been intentional -- the
+focus of this fork is on a few key principles:
+  - Simplicity and improved user experience
+  - Efficiency of operations and performance
+  - Minimize external dependencies and standard library usage.
+  - Of course -- adding much-needed features.
 
 ## Look
 
-General UI desktop (dark mode):
-![image](https://github.com/gtsteffaniak/filebrowser/assets/42989099/11346953-f3eb-4f2f-a833-1d615e0e38bc)
+One way you can observe the improved user experience is how I changed
+the UI. The Navbar is simplified to a three-component system :
 
-[General UI mobile (dark mode)](https://github.com/gtsteffaniak/filebrowser/assets/42989099/634d3ba6-7ac0-425b-8a83-419743e92fec)
+  1. (Left) The slide-out action panel button
+  2. (Middle) The powerful search bar.
+  3. (Right) The view change toggle.
 
-![image](https://github.com/gtsteffaniak/filebrowser/assets/42989099/c8dc8af1-6869-4736-9092-c47f735bbdc0)
+All other functions are moved either into the action menu or popup menus.
+If the action does not depend on context, it will exist in the slide-out
+action panel. If the action is available based on context, it will show up as
+a popup menu.
 
-[However, mobile search still appears very similar to filebrowser/filebrowsers original implementation](https://github.com/gtsteffaniak/filebrowser/assets/42989099/e179b821-f4e2-4568-b895-4e00de371637)
+<p align="center">
+  <img width="800" src="https://github.com/gtsteffaniak/filebrowser/assets/42989099/899152cf-3e69-4179-aa82-752af2df3fc6" title="Main Screenshot">
+    <img width="800" src="https://github.com/user-attachments/assets/18c02d03-5c60-4e15-9c32-3cfe058a0c49" title="Main Screenshot">
+      <img width="800" src="https://github.com/user-attachments/assets/75226dc4-9802-46f0-9e3c-e4403d3275da" title="Main Screenshot">
 
-## Performance
-
-Search Performance - 100x faster search. However, this will be at expense of RAM. if you have < 1 million
-files and folders in the given scope, the RAM usage should be less than 200MB total. RAM requirements
-should scale based on the number of directories.
-
-Also , the approx. time to fully index will vary widely based on performance. A sufficiently performant
-system should fully index within the first 5 minutes, potentially within the first few seconds.
-
-For example, a low end 11th gen i5 with SSD indexes 86K files within 1 second:
-
-```
-2023/08/01 00:08:29 Using config file: /.filebrowser.json
-2023/08/01 00:08:29 Indexing files...
-2023/08/01 00:08:29 Listening on [::]:8080
-2023/08/01 00:08:30 Successfully indexed files.
-2023/08/01 00:08:30 Files found       : 85310
-2023/08/01 00:08:30 Directories found : 1711
-2023/08/01 00:08:30 Indexing scheduler will run every 5 minutes
-```
+</p>
 
 ## Install
 
 Using docker:
 
-1. docker run:
+1. docker run (no persistent db):
 
 ```
-docker run -it -v /path/to/folder:/srv -p 8080:8080 gtstef/filebrowser
+docker run -it -v /path/to/folder:/srv -p 80:80 gtstef/filebrowser
 ```
 
 1. docker-compose:
@@ -93,12 +90,13 @@ version: '3.7'
 services:
   filebrowser:
     volumes:
-      - '/path/to/folder:/srv'
-      #- './database/:/database/'
-      - './config.json:/.filebrowser.json'
+      - '/path/to/folder:/srv' # required (for now not configurable)
+      - './database:/database'  # optional if you want db to persist - configure a path under "database" dir in config file.
+      - './filebrowser.yaml:/filebrowser.yaml' # required
     ports:
-      - '8080:8080'
+      - '80:80'
     image: gtstef/filebrowser
+    restart: always
 ```
 
   - with network share
@@ -108,30 +106,61 @@ version: '3.7'
 services:
   filebrowser:
     volumes:
-      - 'nas:/srv'
-      #- './database/:/database/'
-      #- './config.json:/.filebrowser.json'
+      - 'storage:/srv' # required (for now not configurable)
+      - './database:/database'  # optional if you want db to persist - configure a path under "database" dir in config file.
+      - './filebrowser.yaml:/filebrowser.yaml' # required
     ports:
-      - '8080:80'
+      - '80:80'
     image: gtstef/filebrowser
+    restart: always
 volumes:
-  nas:
+  storage:
     driver_opts:
       type: cifs
-      o: "username=myusername,password=mypassword,rw"
-      device: "//fileshare/"
+      o: "username=admin,password=password,rw" # enter valid info here
+      device: "//192.168.1.100/share/"         # enter valid hinfo here
+
+```
+
+Not using docker (not recommended), download your binary from releases and run with your custom config file:
+
+```
+./filebrowser -c <filebrowser.yml or other /path/to/config.yaml>
 ```
 
 ## Configuration
 
-Note: still a WIP migrating configuration to json.
+All configuration is now done via a single configuration file:
+`filebrowser.yaml`, here is an example of minimal [configuration
+file](./backend/filebrowser.yaml).
 
-All configuration is now done via the filebrowser.json config file.
-This was chosen because it works best with a docker first use case.
+View the [Configuration Help Page](./configuration.md) for available
+configuration options and other help.
 
-Previously the primary way to configure filebrowser was via flags.
-But this quickly became cumbersome if you had many configurations to make
 
-The other method to configure was via `filebrowser config` commands which
-would write configurations to a db if it existed already.
-When considering
+## Migration from filebrowser/filebrowser
+
+If you currently use filebrowser from the filebrowser/filebrowser
+repo but want to try using this. I recommend you start fresh without
+reusing the database, but there are a few things you'll need to do if you
+must migrate:
+
+1. Create a configuration file as mentioned above.
+2. Copy your database file from the original filebrowser to the path of
+   the new one.
+3. Update the configuration file to use the database (under server in
+   filebrowser.yml)
+4. If you are using docker, update the docker-compose file or docker run
+   command to use the config file as described in the install section
+   above.
+5. If you are not using docker, just make sure you run filebrowser -c
+   filebrowser.yml and have a valid filebrowser config.
+
+
+The filebrowser application should run with the same user and rules that
+you have from the original. But keep in mind the differences that are
+mentioned at the top of this readme.
+
+## Roadmap
+
+see [Roadmap Page](./roadmap.md)

backend/.filebrowser.json

@@ -1,10 +0,0 @@
-{
-
-  "port": 8080,
-  "baseURL": "",
-  "address": "",
-  "log": "stdout",
-  "database": "./database.db",
-  "root": "/srv"
-
-}

backend/.goreleaser.yaml

@@ -0,0 +1,44 @@
+# .goreleaser.yaml
+project_name: filebrowser
+version: 2
+
+builds:
+  # Build configuration for darwin and linux
+  - id: default
+    ldflags:
+      - -s -w
+    main: main.go
+    binary: filebrowser
+    goos:
+      - darwin
+      - linux
+    goarch:
+      - amd64
+      - arm
+      - arm64
+    goarm:
+      - 6
+      - 7
+    hooks:
+      post: 
+        - upx {{ .Path }}  # Compress the binary with UPX
+
+  # Build configuration for windows without arm
+  - id: windows
+    ldflags:
+      - -s -w
+    main: main.go
+    binary: filebrowser
+    goos:
+      - windows
+    goarch:
+      - amd64
+      - arm64
+
+archives:
+  - name_template: "{{.Os}}-{{.Arch}}{{if .Arm}}v{{.Arm}}{{end}}-{{ .ProjectName }}"
+    format: binary
+
+checksum:
+  disable: true
+

backend/auth/auth.go

@@ -3,14 +3,13 @@ package auth
 import (
 	"net/http"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 // Auther is the authentication interface.
 type Auther interface {
 	// Auth is called to authenticate a request.
-	Auth(r *http.Request, usr users.Store, stg *settings.Settings, srv *settings.Server) (*users.User, error)
+	Auth(r *http.Request, usr users.Store) (*users.User, error)
 	// LoginPage indicates if this auther needs a login page.
 	LoginPage() bool
 }

backend/auth/hook.go

@@ -10,14 +10,10 @@ import (
 	"strings"
 
 	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/files"
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
-// MethodHookAuth is used to identify hook auth.
-const MethodHookAuth = "hook"
-
 type hookCred struct {
 	Password string `json:"password"`
 	Username string `json:"username"`
@@ -34,7 +30,7 @@ type HookAuth struct {
 }
 
 // Auth authenticates the user via a json in content body.
-func (a *HookAuth) Auth(r *http.Request, usr users.Store, stg *settings.Settings, srv *settings.Server) (*users.User, error) {
+func (a *HookAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
 	var cred hookCred
 
 	if r.Body == nil {
@@ -47,8 +43,8 @@ func (a *HookAuth) Auth(r *http.Request, usr users.Store, stg *settings.Settings
 	}
 
 	a.Users = usr
-	a.Settings = stg
-	a.Server = srv
+	a.Settings = &settings.Config
+	a.Server = &settings.Config.Server
 	a.Cred = cred
 
 	action, err := a.RunCommand()
@@ -149,23 +145,18 @@ func (a *HookAuth) SaveUser() (*users.User, error) {
 	}
 
 	if u == nil {
-		pass, err := users.HashPwd(a.Cred.Password)
-		if err != nil {
-			return nil, err
-		}
-
 		// create user with the provided credentials
 		d := &users.User{
 			Username:     a.Cred.Username,
-			Password:     pass,
-			Scope:        a.Settings.Defaults.Scope,
-			Locale:       a.Settings.Defaults.Locale,
-			ViewMode:     a.Settings.Defaults.ViewMode,
-			SingleClick:  a.Settings.Defaults.SingleClick,
-			Sorting:      a.Settings.Defaults.Sorting,
-			Perm:         a.Settings.Defaults.Perm,
-			Commands:     a.Settings.Defaults.Commands,
-			HideDotfiles: a.Settings.Defaults.HideDotfiles,
+			Password:     a.Cred.Password,
+			Scope:        a.Settings.UserDefaults.Scope,
+			Locale:       a.Settings.UserDefaults.Locale,
+			ViewMode:     a.Settings.UserDefaults.ViewMode,
+			SingleClick:  a.Settings.UserDefaults.SingleClick,
+			Sorting:      a.Settings.UserDefaults.Sorting,
+			Perm:         a.Settings.UserDefaults.Perm,
+			Commands:     a.Settings.UserDefaults.Commands,
+			HideDotfiles: a.Settings.UserDefaults.HideDotfiles,
 		}
 		u = a.GetUser(d)
 
@@ -182,16 +173,6 @@ func (a *HookAuth) SaveUser() (*users.User, error) {
 		}
 	} else if p := !users.CheckPwd(a.Cred.Password, u.Password); len(a.Fields.Values) > 1 || p {
 		u = a.GetUser(u)
-
-		// update the password when it doesn't match the current
-		if p {
-			pass, err := users.HashPwd(a.Cred.Password)
-			if err != nil {
-				return nil, err
-			}
-			u.Password = pass
-		}
-
 		// update user with provided fields
 		err := a.Users.Update(u)
 		if err != nil {
@@ -205,31 +186,31 @@ func (a *HookAuth) SaveUser() (*users.User, error) {
 // GetUser returns a User filled with hook values or provided defaults
 func (a *HookAuth) GetUser(d *users.User) *users.User {
 	// adds all permissions when user is admin
-	isAdmin := a.Fields.GetBoolean("user.perm.admin", d.Perm.Admin)
+	isAdmin := d.Perm.Admin
 	perms := users.Permissions{
 		Admin:    isAdmin,
-		Execute:  isAdmin || a.Fields.GetBoolean("user.perm.execute", d.Perm.Execute),
-		Create:   isAdmin || a.Fields.GetBoolean("user.perm.create", d.Perm.Create),
-		Rename:   isAdmin || a.Fields.GetBoolean("user.perm.rename", d.Perm.Rename),
-		Modify:   isAdmin || a.Fields.GetBoolean("user.perm.modify", d.Perm.Modify),
-		Delete:   isAdmin || a.Fields.GetBoolean("user.perm.delete", d.Perm.Delete),
-		Share:    isAdmin || a.Fields.GetBoolean("user.perm.share", d.Perm.Share),
-		Download: isAdmin || a.Fields.GetBoolean("user.perm.download", d.Perm.Download),
+		Execute:  isAdmin || d.Perm.Execute,
+		Create:   isAdmin || d.Perm.Create,
+		Rename:   isAdmin || d.Perm.Rename,
+		Modify:   isAdmin || d.Perm.Modify,
+		Delete:   isAdmin || d.Perm.Delete,
+		Share:    isAdmin || d.Perm.Share,
+		Download: isAdmin || d.Perm.Download,
 	}
 	user := users.User{
 		ID:          d.ID,
 		Username:    d.Username,
 		Password:    d.Password,
-		Scope:       a.Fields.GetString("user.scope", d.Scope),
-		Locale:      a.Fields.GetString("user.locale", d.Locale),
-		ViewMode:    users.ViewMode(a.Fields.GetString("user.viewMode", string(d.ViewMode))),
-		SingleClick: a.Fields.GetBoolean("user.singleClick", d.SingleClick),
-		Sorting: files.Sorting{
-			Asc: a.Fields.GetBoolean("user.sorting.asc", d.Sorting.Asc),
-			By:  a.Fields.GetString("user.sorting.by", d.Sorting.By),
+		Scope:       d.Scope,
+		Locale:      d.Locale,
+		ViewMode:    d.ViewMode,
+		SingleClick: d.SingleClick,
+		Sorting: users.Sorting{
+			Asc: d.Sorting.Asc,
+			By:  d.Sorting.By,
 		},
-		Commands:     a.Fields.GetArray("user.commands", d.Commands),
-		HideDotfiles: a.Fields.GetBoolean("user.hideDotfiles", d.HideDotfiles),
+		Commands:     d.Commands,
+		HideDotfiles: d.HideDotfiles,
 		Perm:         perms,
 		LockPassword: true,
 	}

backend/auth/json.go

@@ -11,9 +11,6 @@ import (
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
-// MethodJSONAuth is used to identify json auth.
-const MethodJSONAuth = "json"
-
 type jsonCred struct {
 	Password  string `json:"password"`
 	Username  string `json:"username"`
@@ -26,13 +23,13 @@ type JSONAuth struct {
 }
 
 // Auth authenticates the user via a json in content body.
-func (a JSONAuth) Auth(r *http.Request, usr users.Store, stg *settings.Settings, srv *settings.Server) (*users.User, error) {
+func (a JSONAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
+	config := &settings.Config
 	var cred jsonCred
 
 	if r.Body == nil {
 		return nil, os.ErrPermission
 	}
-
 	err := json.NewDecoder(r.Body).Decode(&cred)
 	if err != nil {
 		return nil, os.ErrPermission
@@ -51,7 +48,7 @@ func (a JSONAuth) Auth(r *http.Request, usr users.Store, stg *settings.Settings,
 		}
 	}
 
-	u, err := usr.Get(srv.Root, cred.Username)
+	u, err := usr.Get(config.Server.Root, cred.Username)
 	if err != nil || !users.CheckPwd(cred.Password, u.Password) {
 		return nil, os.ErrPermission
 	}

backend/auth/none.go

@@ -14,8 +14,8 @@ const MethodNoAuth = "noauth"
 type NoAuth struct{}
 
 // Auth uses authenticates user 1.
-func (a NoAuth) Auth(r *http.Request, usr users.Store, stg *settings.Settings, srv *settings.Server) (*users.User, error) {
-	return usr.Get(srv.Root, uint(1))
+func (a NoAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
+	return usr.Get(settings.Config.Server.Root, uint(1))
 }
 
 // LoginPage tells that no auth doesn't require a login page.

backend/auth/proxy.go

@@ -4,8 +4,9 @@ import (
 	"net/http"
 	"os"
 
-	"github.com/gtsteffaniak/filebrowser/errors"
 	"github.com/gtsteffaniak/filebrowser/settings"
+
+	"github.com/gtsteffaniak/filebrowser/errors"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
@@ -18,9 +19,9 @@ type ProxyAuth struct {
 }
 
 // Auth authenticates the user via an HTTP header.
-func (a ProxyAuth) Auth(r *http.Request, usr users.Store, stg *settings.Settings, srv *settings.Server) (*users.User, error) {
+func (a ProxyAuth) Auth(r *http.Request, usr users.Store) (*users.User, error) {
 	username := r.Header.Get(a.Header)
-	user, err := usr.Get(srv.Root, username)
+	user, err := usr.Get(settings.Config.Server.Root, username)
 	if err == errors.ErrNotExist {
 		return nil, os.ErrPermission
 	}

backend/benchmark_results.txt

@@ -0,0 +1,53 @@
+
+ == Running benchmark == 
+/usr/local/go/bin/go
+?   	github.com/gtsteffaniak/filebrowser	[no test files]
+?   	github.com/gtsteffaniak/filebrowser/auth	[no test files]
+?   	github.com/gtsteffaniak/filebrowser/cmd	[no test files]
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/diskcache	0.003s
+?   	github.com/gtsteffaniak/filebrowser/errors	[no test files]
+goos: linux
+goarch: amd64
+pkg: github.com/gtsteffaniak/filebrowser/files
+cpu: 11th Gen Intel(R) Core(TM) i5-11320H @ 3.20GHz
+BenchmarkFillIndex-8          	      10	   3587120 ns/op	  273640 B/op	    2013 allocs/op
+BenchmarkSearchAllIndexes-8   	      10	  31291180 ns/op	19500700 B/op	  298636 allocs/op
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/files	0.408s
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/fileutils	0.003s
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 h: 401  <nil>
+2024/02/07 07:16:43 h: 401  <nil>
+2024/02/07 07:16:43 h: 401  <nil>
+2024/02/07 07:16:43 h: 401  <nil>
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 Saving new user: publicUser
+2024/02/07 07:16:43 h: 401  <nil>
+2024/02/07 07:16:43 h: 401  <nil>
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/http	0.202s
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/img	0.125s
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/rules	0.002s
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/runner	0.003s
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/settings	0.005s
+?   	github.com/gtsteffaniak/filebrowser/share	[no test files]
+?   	github.com/gtsteffaniak/filebrowser/storage	[no test files]
+?   	github.com/gtsteffaniak/filebrowser/storage/bolt	[no test files]
+PASS
+ok  	github.com/gtsteffaniak/filebrowser/users	0.003s
+?   	github.com/gtsteffaniak/filebrowser/version	[no test files]

backend/cmd/cmd.go

@@ -1,12 +0,0 @@
-package cmd
-
-import (
-	"log"
-)
-
-// Execute executes the commands.
-func Execute() {
-	if err := rootCmd.Execute(); err != nil {
-		log.Fatal(err)
-	}
-}

backend/cmd/cmds.go

@@ -1,26 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	rootCmd.AddCommand(cmdsCmd)
-}
-
-var cmdsCmd = &cobra.Command{
-	Use:   "cmds",
-	Short: "Command runner management utility",
-	Long:  `Command runner management utility.`,
-	Args:  cobra.NoArgs,
-}
-
-func printEvents(m map[string][]string) {
-	for evt, cmds := range m {
-		for i, cmd := range cmds {
-			fmt.Printf("%s(%d): %s\n", evt, i, cmd)
-		}
-	}
-}

backend/cmd/cmds_add.go

@@ -1,27 +0,0 @@
-package cmd
-
-import (
-	"strings"
-
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	cmdsCmd.AddCommand(cmdsAddCmd)
-}
-
-var cmdsAddCmd = &cobra.Command{
-	Use:   "add <event> <command>",
-	Short: "Add a command to run on a specific event",
-	Long:  `Add a command to run on a specific event.`,
-	Args:  cobra.MinimumNArgs(2), //nolint:gomnd
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := d.store.Settings.Get()
-		checkErr(err)
-		command := strings.Join(args[1:], " ")
-		s.Commands[args[0]] = append(s.Commands[args[0]], command)
-		err = d.store.Settings.Save(s)
-		checkErr(err)
-		printEvents(s.Commands)
-	}, pythonConfig{}),
-}

backend/cmd/cmds_ls.go

@@ -1,31 +0,0 @@
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	cmdsCmd.AddCommand(cmdsLsCmd)
-	cmdsLsCmd.Flags().StringP("event", "e", "", "event name, without 'before' or 'after'")
-}
-
-var cmdsLsCmd = &cobra.Command{
-	Use:   "ls",
-	Short: "List all commands for each event",
-	Long:  `List all commands for each event.`,
-	Args:  cobra.NoArgs,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := d.store.Settings.Get()
-		checkErr(err)
-		evt := mustGetString(cmd.Flags(), "event")
-
-		if evt == "" {
-			printEvents(s.Commands)
-		} else {
-			show := map[string][]string{}
-			show["before_"+evt] = s.Commands["before_"+evt]
-			show["after_"+evt] = s.Commands["after_"+evt]
-			printEvents(show)
-		}
-	}, pythonConfig{}),
-}

backend/cmd/cmds_rm.go

@@ -1,56 +0,0 @@
-package cmd
-
-import (
-	"strconv"
-
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	cmdsCmd.AddCommand(cmdsRmCmd)
-}
-
-var cmdsRmCmd = &cobra.Command{
-	Use:   "rm <event> <index> [index_end]",
-	Short: "Removes a command from an event hooker",
-	Long: `Removes a command from an event hooker. The provided index
-is the same that's printed when you run 'cmds ls'. Note
-that after each removal/addition, the index of the
-commands change. So be careful when removing them after each
-other.
-
-You can also specify an optional parameter (index_end) so
-you can remove all commands from 'index' to 'index_end',
-including 'index_end'.`,
-	Args: func(cmd *cobra.Command, args []string) error {
-		if err := cobra.RangeArgs(2, 3)(cmd, args); err != nil { //nolint:gomnd
-			return err
-		}
-
-		for _, arg := range args[1:] {
-			if _, err := strconv.Atoi(arg); err != nil {
-				return err
-			}
-		}
-
-		return nil
-	},
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := d.store.Settings.Get()
-		checkErr(err)
-		evt := args[0]
-
-		i, err := strconv.Atoi(args[1])
-		checkErr(err)
-		f := i
-		if len(args) == 3 { //nolint:gomnd
-			f, err = strconv.Atoi(args[2])
-			checkErr(err)
-		}
-
-		s.Commands[evt] = append(s.Commands[evt][:i], s.Commands[evt][f+1:]...)
-		err = d.store.Settings.Save(s)
-		checkErr(err)
-		printEvents(s.Commands)
-	}, pythonConfig{}),
-}

backend/cmd/config.go

@@ -1,186 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	nerrors "errors"
-	"fmt"
-	"os"
-	"strings"
-	"text/tabwriter"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	"github.com/gtsteffaniak/filebrowser/auth"
-	"github.com/gtsteffaniak/filebrowser/errors"
-	"github.com/gtsteffaniak/filebrowser/settings"
-)
-
-func init() {
-	rootCmd.AddCommand(configCmd)
-}
-
-var configCmd = &cobra.Command{
-	Use:   "config",
-	Short: "Configuration management utility",
-	Long:  `Configuration management utility.`,
-	Args:  cobra.NoArgs,
-}
-
-func addConfigFlags(flags *pflag.FlagSet) {
-	addServerFlags(flags)
-	addUserFlags(flags)
-	flags.BoolP("signup", "s", false, "allow users to signup")
-	flags.String("shell", "", "shell command to which other commands should be appended")
-
-	flags.String("auth.method", string(auth.MethodJSONAuth), "authentication type")
-	flags.String("auth.header", "", "HTTP header for auth.method=proxy")
-	flags.String("auth.command", "", "command for auth.method=hook")
-
-	flags.String("recaptcha.host", "https://www.google.com", "use another host for ReCAPTCHA. recaptcha.net might be useful in China")
-	flags.String("recaptcha.key", "", "ReCaptcha site key")
-	flags.String("recaptcha.secret", "", "ReCaptcha secret")
-
-	flags.String("branding.name", "", "replace 'File Browser' by this name")
-	flags.String("branding.color", "", "set the theme color")
-	flags.String("branding.files", "", "path to directory with images and custom styles")
-	flags.Bool("branding.disableExternal", false, "disable external links such as GitHub links")
-	flags.Bool("branding.disableUsedPercentage", false, "disable used disk percentage graph")
-}
-
-//nolint:gocyclo
-func getAuthentication(flags *pflag.FlagSet, defaults ...interface{}) (string, auth.Auther) {
-	method := mustGetString(flags, "auth.method")
-
-	var defaultAuther map[string]interface{}
-	if len(defaults) > 0 {
-		if hasAuth := defaults[0]; hasAuth != true {
-			for _, arg := range defaults {
-				switch def := arg.(type) {
-				case *settings.Settings:
-					method = def.AuthMethod
-				case auth.Auther:
-					ms, err := json.Marshal(def)
-					checkErr(err)
-					err = json.Unmarshal(ms, &defaultAuther)
-					checkErr(err)
-				}
-			}
-		}
-	}
-
-	var auther auth.Auther
-	if method == auth.MethodProxyAuth {
-		header := mustGetString(flags, "auth.header")
-
-		if header == "" {
-			header = defaultAuther["header"].(string)
-		}
-
-		if header == "" {
-			checkErr(nerrors.New("you must set the flag 'auth.header' for method 'proxy'"))
-		}
-
-		auther = &auth.ProxyAuth{Header: header}
-	}
-
-	if method == auth.MethodNoAuth {
-		auther = &auth.NoAuth{}
-	}
-
-	if method == auth.MethodJSONAuth {
-		jsonAuth := &auth.JSONAuth{}
-		host := mustGetString(flags, "recaptcha.host")
-		key := mustGetString(flags, "recaptcha.key")
-		secret := mustGetString(flags, "recaptcha.secret")
-
-		if key == "" {
-			if kmap, ok := defaultAuther["recaptcha"].(map[string]interface{}); ok {
-				key = kmap["key"].(string)
-			}
-		}
-
-		if secret == "" {
-			if smap, ok := defaultAuther["recaptcha"].(map[string]interface{}); ok {
-				secret = smap["secret"].(string)
-			}
-		}
-
-		if key != "" && secret != "" {
-			jsonAuth.ReCaptcha = &auth.ReCaptcha{
-				Host:   host,
-				Key:    key,
-				Secret: secret,
-			}
-		}
-		auther = jsonAuth
-	}
-
-	if method == auth.MethodHookAuth {
-		command := mustGetString(flags, "auth.command")
-
-		if command == "" {
-			command = defaultAuther["command"].(string)
-		}
-
-		if command == "" {
-			checkErr(nerrors.New("you must set the flag 'auth.command' for method 'hook'"))
-		}
-
-		auther = &auth.HookAuth{Command: command}
-	}
-
-	if auther == nil {
-		panic(errors.ErrInvalidAuthMethod)
-	}
-
-	return method, auther
-}
-
-func printSettings(ser *settings.Server, set *settings.Settings, auther auth.Auther) {
-	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0) //nolint:gomnd
-
-	fmt.Fprintf(w, "Sign up:\t%t\n", set.Signup)
-	fmt.Fprintf(w, "Create User Dir:\t%t\n", set.CreateUserDir)
-	fmt.Fprintf(w, "Auth method:\t%s\n", set.AuthMethod)
-	fmt.Fprintf(w, "Shell:\t%s\t\n", strings.Join(set.Shell, " "))
-	fmt.Fprintln(w, "\nBranding:")
-	fmt.Fprintf(w, "\tName:\t%s\n", set.Branding.Name)
-	fmt.Fprintf(w, "\tFiles override:\t%s\n", set.Branding.Files)
-	fmt.Fprintf(w, "\tDisable external links:\t%t\n", set.Branding.DisableExternal)
-	fmt.Fprintf(w, "\tDisable used disk percentage graph:\t%t\n", set.Branding.DisableUsedPercentage)
-	fmt.Fprintf(w, "\tColor:\t%s\n", set.Branding.Color)
-	fmt.Fprintln(w, "\nServer:")
-	fmt.Fprintf(w, "\tLog:\t%s\n", ser.Log)
-	fmt.Fprintf(w, "\tPort:\t%s\n", ser.Port)
-	fmt.Fprintf(w, "\tBase URL:\t%s\n", ser.BaseURL)
-	fmt.Fprintf(w, "\tRoot:\t%s\n", ser.Root)
-	fmt.Fprintf(w, "\tSocket:\t%s\n", ser.Socket)
-	fmt.Fprintf(w, "\tAddress:\t%s\n", ser.Address)
-	fmt.Fprintf(w, "\tTLS Cert:\t%s\n", ser.TLSCert)
-	fmt.Fprintf(w, "\tTLS Key:\t%s\n", ser.TLSKey)
-	fmt.Fprintf(w, "\tExec Enabled:\t%t\n", ser.EnableExec)
-	fmt.Fprintln(w, "\nDefaults:")
-	fmt.Fprintf(w, "\tScope:\t%s\n", set.Defaults.Scope)
-	fmt.Fprintf(w, "\tLocale:\t%s\n", set.Defaults.Locale)
-	fmt.Fprintf(w, "\tView mode:\t%s\n", set.Defaults.ViewMode)
-	fmt.Fprintf(w, "\tSingle Click:\t%t\n", set.Defaults.SingleClick)
-	fmt.Fprintf(w, "\tCommands:\t%s\n", strings.Join(set.Defaults.Commands, " "))
-	fmt.Fprintf(w, "\tSorting:\n")
-	fmt.Fprintf(w, "\t\tBy:\t%s\n", set.Defaults.Sorting.By)
-	fmt.Fprintf(w, "\t\tAsc:\t%t\n", set.Defaults.Sorting.Asc)
-	fmt.Fprintf(w, "\tPermissions:\n")
-	fmt.Fprintf(w, "\t\tAdmin:\t%t\n", set.Defaults.Perm.Admin)
-	fmt.Fprintf(w, "\t\tExecute:\t%t\n", set.Defaults.Perm.Execute)
-	fmt.Fprintf(w, "\t\tCreate:\t%t\n", set.Defaults.Perm.Create)
-	fmt.Fprintf(w, "\t\tRename:\t%t\n", set.Defaults.Perm.Rename)
-	fmt.Fprintf(w, "\t\tModify:\t%t\n", set.Defaults.Perm.Modify)
-	fmt.Fprintf(w, "\t\tDelete:\t%t\n", set.Defaults.Perm.Delete)
-	fmt.Fprintf(w, "\t\tShare:\t%t\n", set.Defaults.Perm.Share)
-	fmt.Fprintf(w, "\t\tDownload:\t%t\n", set.Defaults.Perm.Download)
-	w.Flush()
-
-	b, err := json.MarshalIndent(auther, "", "  ")
-	checkErr(err)
-	fmt.Printf("\nAuther configuration (raw):\n\n%s\n\n", string(b))
-}

backend/cmd/config_cat.go

@@ -1,25 +0,0 @@
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	configCmd.AddCommand(configCatCmd)
-}
-
-var configCatCmd = &cobra.Command{
-	Use:   "cat",
-	Short: "Prints the configuration",
-	Long:  `Prints the configuration.`,
-	Args:  cobra.NoArgs,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		set, err := d.store.Settings.Get()
-		checkErr(err)
-		ser, err := d.store.Settings.GetServer()
-		checkErr(err)
-		auther, err := d.store.Auth.Get(set.AuthMethod)
-		checkErr(err)
-		printSettings(ser, set, auther)
-	}, pythonConfig{}),
-}

backend/cmd/config_export.go

@@ -1,37 +0,0 @@
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-)
-
-func init() {
-	configCmd.AddCommand(configExportCmd)
-}
-
-var configExportCmd = &cobra.Command{
-	Use:   "export <path>",
-	Short: "Export the configuration to a file",
-	Long: `Export the configuration to a file. The path must be for a
-json or yaml file. This exported configuration can be changed,
-and imported again with 'config import' command.`,
-	Args: jsonYamlArg,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		settings, err := d.store.Settings.Get()
-		checkErr(err)
-
-		server, err := d.store.Settings.GetServer()
-		checkErr(err)
-
-		auther, err := d.store.Auth.Get(settings.AuthMethod)
-		checkErr(err)
-
-		data := &settingsFile{
-			Settings: settings,
-			Auther:   auther,
-			Server:   server,
-		}
-
-		err = marshal(args[0], data)
-		checkErr(err)
-	}, pythonConfig{}),
-}

backend/cmd/config_import.go

@@ -1,94 +0,0 @@
-package cmd
-
-import (
-	"encoding/json"
-	"errors"
-	"path/filepath"
-	"reflect"
-
-	"github.com/spf13/cobra"
-
-	"github.com/gtsteffaniak/filebrowser/auth"
-	"github.com/gtsteffaniak/filebrowser/settings"
-)
-
-func init() {
-	configCmd.AddCommand(configImportCmd)
-}
-
-type settingsFile struct {
-	Settings *settings.Settings `json:"settings"`
-	Server   *settings.Server   `json:"server"`
-	Auther   interface{}        `json:"auther"`
-}
-
-var configImportCmd = &cobra.Command{
-	Use:   "import <path>",
-	Short: "Import a configuration file",
-	Long: `Import a configuration file. This will replace all the existing
-configuration. Can be used with or without unexisting databases.
-
-If used with a nonexisting database, a key will be generated
-automatically. Otherwise the key will be kept the same as in the
-database.
-
-The path must be for a json or yaml file.`,
-	Args: jsonYamlArg,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		var key []byte
-		if d.hadDB {
-			settings, err := d.store.Settings.Get()
-			checkErr(err)
-			key = settings.Key
-		} else {
-			key = generateKey()
-		}
-
-		file := settingsFile{}
-		err := unmarshal(args[0], &file)
-		checkErr(err)
-
-		file.Settings.Key = key
-		err = d.store.Settings.Save(file.Settings)
-		checkErr(err)
-
-		err = d.store.Settings.SaveServer(file.Server)
-		checkErr(err)
-
-		var rawAuther interface{}
-		if filepath.Ext(args[0]) != ".json" { //nolint:goconst
-			rawAuther = cleanUpInterfaceMap(file.Auther.(map[interface{}]interface{}))
-		} else {
-			rawAuther = file.Auther
-		}
-
-		var auther auth.Auther
-		switch file.Settings.AuthMethod {
-		case auth.MethodJSONAuth:
-			auther = getAuther(auth.JSONAuth{}, rawAuther).(*auth.JSONAuth)
-		case auth.MethodNoAuth:
-			auther = getAuther(auth.NoAuth{}, rawAuther).(*auth.NoAuth)
-		case auth.MethodProxyAuth:
-			auther = getAuther(auth.ProxyAuth{}, rawAuther).(*auth.ProxyAuth)
-		case auth.MethodHookAuth:
-			auther = getAuther(&auth.HookAuth{}, rawAuther).(*auth.HookAuth)
-		default:
-			checkErr(errors.New("invalid auth method"))
-		}
-
-		err = d.store.Auth.Save(auther)
-		checkErr(err)
-
-		printSettings(file.Server, file.Settings, auther)
-	}, pythonConfig{allowNoDB: true}),
-}
-
-func getAuther(sample auth.Auther, data interface{}) interface{} {
-	authType := reflect.TypeOf(sample)
-	auther := reflect.New(authType).Interface()
-	bytes, err := json.Marshal(data)
-	checkErr(err)
-	err = json.Unmarshal(bytes, &auther)
-	checkErr(err)
-	return auther
-}

backend/cmd/config_init.go

@@ -1,69 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/gtsteffaniak/filebrowser/settings"
-)
-
-func init() {
-	configCmd.AddCommand(configInitCmd)
-	addConfigFlags(configInitCmd.Flags())
-}
-
-var configInitCmd = &cobra.Command{
-	Use:   "init",
-	Short: "Initialize a new database",
-	Long: `Initialize a new database to use with File Browser. All of
-this options can be changed in the future with the command
-'filebrowser config set'. The user related flags apply
-to the defaults when creating new users and you don't
-override the options.`,
-	Args: cobra.NoArgs,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		defaults := settings.UserDefaults{}
-		flags := cmd.Flags()
-		getUserDefaults(flags, &defaults, true)
-		authMethod, auther := getAuthentication(flags)
-
-		s := &settings.Settings{
-			Key:        generateKey(),
-			Signup:     mustGetBool(flags, "signup"),
-			Shell:      convertCmdStrToCmdArray(mustGetString(flags, "shell")),
-			AuthMethod: authMethod,
-			Defaults:   defaults,
-			Branding: settings.Branding{
-				Name:                  mustGetString(flags, "branding.name"),
-				DisableExternal:       mustGetBool(flags, "branding.disableExternal"),
-				DisableUsedPercentage: mustGetBool(flags, "branding.DisableUsedPercentage"),
-				Files:                 mustGetString(flags, "branding.files"),
-			},
-		}
-
-		ser := &settings.Server{
-			Address: mustGetString(flags, "address"),
-			Socket:  mustGetString(flags, "socket"),
-			Root:    mustGetString(flags, "root"),
-			BaseURL: mustGetString(flags, "baseurl"),
-			TLSKey:  mustGetString(flags, "key"),
-			TLSCert: mustGetString(flags, "cert"),
-			Port:    mustGetString(flags, "port"),
-			Log:     mustGetString(flags, "log"),
-		}
-		err := d.store.Settings.Save(s)
-		checkErr(err)
-		err = d.store.Settings.SaveServer(ser)
-		checkErr(err)
-		err = d.store.Auth.Save(auther)
-		checkErr(err)
-
-		fmt.Printf(`
-Congratulations! You've set up your database to use with File Browser.
-Now add your first user via 'filebrowser users add' and then you just
-need to call the main command to boot up the server.
-`)
-		printSettings(ser, s, auther)
-	}, pythonConfig{noDB: true}),
-}

backend/cmd/config_set.go

@@ -1,82 +0,0 @@
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-func init() {
-	configCmd.AddCommand(configSetCmd)
-	addConfigFlags(configSetCmd.Flags())
-}
-
-var configSetCmd = &cobra.Command{
-	Use:   "set",
-	Short: "Updates the configuration",
-	Long: `Updates the configuration. Set the flags for the options
-you want to change. Other options will remain unchanged.`,
-	Args: cobra.NoArgs,
-	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		flags := cmd.Flags()
-		set, err := d.store.Settings.Get()
-		checkErr(err)
-
-		ser, err := d.store.Settings.GetServer()
-		checkErr(err)
-
-		hasAuth := false
-		flags.Visit(func(flag *pflag.Flag) {
-			switch flag.Name {
-			case "baseurl":
-				ser.BaseURL = mustGetString(flags, flag.Name)
-			case "root":
-				ser.Root = mustGetString(flags, flag.Name)
-			case "socket":
-				ser.Socket = mustGetString(flags, flag.Name)
-			case "cert":
-				ser.TLSCert = mustGetString(flags, flag.Name)
-			case "key":
-				ser.TLSKey = mustGetString(flags, flag.Name)
-			case "address":
-				ser.Address = mustGetString(flags, flag.Name)
-			case "port":
-				ser.Port = mustGetString(flags, flag.Name)
-			case "log":
-				ser.Log = mustGetString(flags, flag.Name)
-			case "signup":
-				set.Signup = mustGetBool(flags, flag.Name)
-			case "auth.method":
-				hasAuth = true
-			case "shell":
-				set.Shell = convertCmdStrToCmdArray(mustGetString(flags, flag.Name))
-			case "branding.name":
-				set.Branding.Name = mustGetString(flags, flag.Name)
-			case "branding.color":
-				set.Branding.Color = mustGetString(flags, flag.Name)
-			case "branding.disableExternal":
-				set.Branding.DisableExternal = mustGetBool(flags, flag.Name)
-			case "branding.disableUsedPercentage":
-				set.Branding.DisableUsedPercentage = mustGetBool(flags, flag.Name)
-			case "branding.files":
-				set.Branding.Files = mustGetString(flags, flag.Name)
-			}
-		})
-
-		getUserDefaults(flags, &set.Defaults, false)
-
-		// read the defaults
-		auther, err := d.store.Auth.Get(set.AuthMethod)
-		checkErr(err)
-
-		// check if there are new flags for existing auth method
-		set.AuthMethod, auther = getAuthentication(flags, hasAuth, set, auther)
-
-		err = d.store.Auth.Save(auther)
-		checkErr(err)
-		err = d.store.Settings.Save(set)
-		checkErr(err)
-		err = d.store.Settings.SaveServer(ser)
-		checkErr(err)
-		printSettings(ser, set, auther)
-	}, pythonConfig{}),
-}

backend/cmd/dist/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

backend/cmd/docs.go

@@ -1,139 +0,0 @@
-package cmd
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-func init() {
-	rootCmd.AddCommand(docsCmd)
-	docsCmd.Flags().StringP("path", "p", "./docs", "path to save the docs")
-}
-
-func printToc(names []string) {
-	for i, name := range names {
-		name = strings.TrimSuffix(name, filepath.Ext(name))
-		name = strings.Replace(name, "-", " ", -1)
-		names[i] = name
-	}
-
-	sort.Strings(names)
-
-	toc := ""
-	for _, name := range names {
-		toc += "* [" + name + "](cli/" + strings.Replace(name, " ", "-", -1) + ".md)\n"
-	}
-
-	fmt.Println(toc)
-}
-
-var docsCmd = &cobra.Command{
-	Use:    "docs",
-	Hidden: true,
-	Args:   cobra.NoArgs,
-	Run: func(cmd *cobra.Command, args []string) {
-		dir := mustGetString(cmd.Flags(), "path")
-		generateDocs(rootCmd, dir)
-		names := []string{}
-
-		err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
-			if err != nil || info.IsDir() {
-				return err
-			}
-
-			if !strings.HasPrefix(info.Name(), "filebrowser") {
-				return nil
-			}
-
-			names = append(names, info.Name())
-			return nil
-		})
-
-		checkErr(err)
-		printToc(names)
-	},
-}
-
-func generateDocs(cmd *cobra.Command, dir string) {
-	for _, c := range cmd.Commands() {
-		if !c.IsAvailableCommand() || c.IsAdditionalHelpTopicCommand() {
-			continue
-		}
-
-		generateDocs(c, dir)
-	}
-
-	basename := strings.Replace(cmd.CommandPath(), " ", "-", -1) + ".md"
-	filename := filepath.Join(dir, basename)
-	f, err := os.Create(filename)
-	checkErr(err)
-	defer f.Close()
-	generateMarkdown(cmd, f)
-}
-
-func generateMarkdown(cmd *cobra.Command, w io.Writer) {
-	cmd.InitDefaultHelpCmd()
-	cmd.InitDefaultHelpFlag()
-
-	buf := new(bytes.Buffer)
-	name := cmd.CommandPath()
-
-	short := cmd.Short
-	long := cmd.Long
-	if long == "" {
-		long = short
-	}
-
-	buf.WriteString("---\ndescription: " + short + "\n---\n\n")
-	buf.WriteString("# " + name + "\n\n")
-	buf.WriteString("## Synopsis\n\n")
-	buf.WriteString(long + "\n\n")
-
-	if cmd.Runnable() {
-		buf.WriteString(fmt.Sprintf("```\n%s\n```\n\n", cmd.UseLine()))
-	}
-
-	if len(cmd.Example) > 0 {
-		buf.WriteString("## Examples\n\n")
-		buf.WriteString(fmt.Sprintf("```\n%s\n```\n\n", cmd.Example))
-	}
-
-	printOptions(buf, cmd)
-	_, err := buf.WriteTo(w)
-	checkErr(err)
-}
-
-func generateFlagsTable(fs *pflag.FlagSet, buf io.StringWriter) {
-	_, _ = buf.WriteString("| Name | Shorthand | Usage |\n")
-	_, _ = buf.WriteString("|------|-----------|-------|\n")
-
-	fs.VisitAll(func(f *pflag.Flag) {
-		_, _ = buf.WriteString("|" + f.Name + "|" + f.Shorthand + "|" + f.Usage + "|\n")
-	})
-}
-
-func printOptions(buf *bytes.Buffer, cmd *cobra.Command) {
-	flags := cmd.NonInheritedFlags()
-	flags.SetOutput(buf)
-	if flags.HasAvailableFlags() {
-		buf.WriteString("## Options\n\n")
-		generateFlagsTable(flags, buf)
-		buf.WriteString("\n")
-	}
-
-	parentFlags := cmd.InheritedFlags()
-	parentFlags.SetOutput(buf)
-	if parentFlags.HasAvailableFlags() {
-		buf.WriteString("### Inherited\n\n")
-		generateFlagsTable(parentFlags, buf)
-		buf.WriteString("\n")
-	}
-}

backend/cmd/hash.go

@@ -1,25 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/gtsteffaniak/filebrowser/users"
-)
-
-func init() {
-	rootCmd.AddCommand(hashCmd)
-}
-
-var hashCmd = &cobra.Command{
-	Use:   "hash <password>",
-	Short: "Hashes a password",
-	Long:  `Hashes a password using bcrypt algorithm.`,
-	Args:  cobra.ExactArgs(1),
-	Run: func(cmd *cobra.Command, args []string) {
-		pwd, err := users.HashPwd(args[0])
-		checkErr(err)
-		fmt.Println(pwd)
-	},
-}

backend/cmd/root.go

@@ -2,38 +2,37 @@ package cmd
 
 import (
 	"crypto/tls"
-	"errors"
-	"io"
+	"flag"
+	"fmt"
 	"io/fs"
 	"log"
 	"net"
 	"net/http"
 	"os"
 	"os/signal"
-	"path/filepath"
 	"strconv"
-	"strings"
 	"syscall"
 
+	"embed"
+
+	"github.com/spf13/pflag"
+
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-	v "github.com/spf13/viper"
-	lumberjack "gopkg.in/natefinch/lumberjack.v2"
 
 	"github.com/gtsteffaniak/filebrowser/auth"
 	"github.com/gtsteffaniak/filebrowser/diskcache"
+	"github.com/gtsteffaniak/filebrowser/files"
 	fbhttp "github.com/gtsteffaniak/filebrowser/http"
 	"github.com/gtsteffaniak/filebrowser/img"
-	"github.com/gtsteffaniak/filebrowser/search"
 	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
-var (
-	cfgFile string
-)
+//go:embed dist/*
+var assets embed.FS
+
+var nonEmbededFS = os.Getenv("FILEBROWSER_NO_EMBEDED") == "true"
 
 type dirFS struct {
 	http.Dir
@@ -44,106 +43,29 @@ func (d dirFS) Open(name string) (fs.File, error) {
 }
 
 func init() {
-	cobra.OnInitialize(initConfig)
-	cobra.MousetrapHelpText = ""
-	rootCmd.SetVersionTemplate("File Browser version {{printf \"%s\" .Version}}\n")
-
-	flags := rootCmd.Flags()
-
-	persistent := rootCmd.PersistentFlags()
-
-	persistent.StringVarP(&cfgFile, "config", "c", "", "config file path")
-	persistent.StringP("database", "d", "./filebrowser.db", "database path")
-	flags.Bool("noauth", false, "use the noauth auther when using quick setup")
-	flags.String("username", "admin", "username for the first user when using quick config")
-	flags.String("password", "", "hashed password for the first user when using quick config (default \"admin\")")
-
-	addServerFlags(flags)
-}
-
-func getEnvVariableAsUint32(key string) uint32 {
-	valueStr := os.Getenv(key)
-	value, err := strconv.ParseUint(valueStr, 10, 32)
-	if err != nil {
-		return 5 // default value every 5 minutes
-	}
-	return uint32(value)
-}
-
-func addServerFlags(flags *pflag.FlagSet) {
-	flags.StringP("address", "a", "127.0.0.1", "address to listen on")
-	flags.StringP("log", "l", "stdout", "log output")
-	flags.StringP("port", "p", "8080", "port to listen on")
-	flags.StringP("cert", "t", "", "tls certificate")
-	flags.StringP("key", "k", "", "tls key")
-	flags.StringP("root", "r", ".", "root to prepend to relative paths")
-	flags.String("socket", "", "socket to listen to (cannot be used with address, port, cert nor key flags)")
-	flags.Uint32("socket-perm", 0666, "unix socket file permissions") //nolint:gomnd
-	flags.StringP("baseurl", "b", "", "base url")
-	flags.String("cache-dir", "", "file cache directory (disabled if empty)")
-	flags.Int("img-processors", 4, "image processors count") //nolint:gomnd
-	flags.Bool("disable-thumbnails", false, "disable image thumbnails")
-	flags.Bool("disable-preview-resize", true, "disable resize of image previews")
-	flags.Bool("disable-exec", false, "disables Command Runner feature")
-	flags.Bool("disable-type-detection-by-header", false, "disables type detection by reading file headers")
+	// Define a flag for the config option (-c or --config)
+	configFlag := pflag.StringP("config", "c", "filebrowser.yaml", "Path to the config file")
+	// Bind the flags to the pflag command line parser
+	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
+	pflag.Parse()
+	log.Println("Initializing with config file:", *configFlag)
+	log.Println("Embeded Frontend:", !nonEmbededFS)
+	settings.Initialize(*configFlag)
 }
 
 var rootCmd = &cobra.Command{
-	Use:   "filebrowser",
-	Short: "A stylish web-based file browser",
-	Long: `File Browser CLI lets you create the database to use with File Browser,
-manage your users and all the configurations without acessing the
-web interface.
-
-If you've never run File Browser, you'll need to have a database for
-it. Don't worry: you don't need to setup a separate database server.
-We're using Bolt DB which is a single file database and all managed
-by ourselves.
-
-For this specific command, all the flags you have available (except
-"config" for the configuration file), can be given either through
-environment variables or configuration files.
-
-If you don't set "config", it will look for a configuration file called
-.filebrowser.{json, toml, yaml, yml} in the following directories:
-
-- ./
-- $HOME/
-- /etc/filebrowser/
-
-The precedence of the configuration values are as follows:
-
-- flags
-- environment variables
-- configuration file
-- database values
-- defaults
-
-The environment variables are prefixed by "FB_" followed by the option
-name in caps. So to set "database" via an env variable, you should
-set FB_DATABASE.
-
-Also, if the database path doesn't exist, File Browser will enter into
-the quick setup mode and a new database will be bootstraped and a new
-user created with the credentials from options "username" and "password".`,
+	Use: "filebrowser",
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		log.Println(cfgFile)
-
+		serverConfig := settings.Config.Server
 		if !d.hadDB {
-			quickSetup(cmd.Flags(), d)
+			quickSetup(d)
 		}
-
-		// build img service
-		workersCount, err := cmd.Flags().GetInt("img-processors")
-		checkErr(err)
-		if workersCount < 1 {
+		if serverConfig.NumImageProcessors < 1 {
 			log.Fatal("Image resize workers count could not be < 1")
 		}
-		imgSvc := img.New(workersCount)
-
+		imgSvc := img.New(serverConfig.NumImageProcessors)
 		var fileCache diskcache.Interface = diskcache.NewNoOp()
-		cacheDir, err := cmd.Flags().GetString("cache-dir")
-		checkErr(err)
+		cacheDir := "/tmp"
 		if cacheDir != "" {
 			if err := os.MkdirAll(cacheDir, 0700); err != nil { //nolint:govet,gomnd
 				log.Fatalf("can't make directory %s: %s", cacheDir, err)
@@ -151,59 +73,68 @@ user created with the credentials from options "username" and "password".`,
 			fileCache = diskcache.New(afero.NewOsFs(), cacheDir)
 		}
 		// initialize indexing and schedule indexing ever n minutes (default 5)
-		indexingInterval := getEnvVariableAsUint32("INDEXING_INTERVAL")
-		go search.InitializeIndex(indexingInterval)
-
-		server := getRunParams(cmd.Flags(), d.store)
-		setupLog(server.Log)
-
-		root, err := filepath.Abs(server.Root)
-		checkErr(err)
-		server.Root = root
-
-		adr := server.Address + ":" + server.Port
-
+		go files.InitializeIndex(serverConfig.IndexingInterval, serverConfig.Indexing)
+		_, err := os.Stat(serverConfig.Root)
+		checkErr(fmt.Sprint("cmd os.Stat ", serverConfig.Root), err)
 		var listener net.Listener
-
+		address := serverConfig.Address + ":" + strconv.Itoa(serverConfig.Port)
 		switch {
-		case server.Socket != "":
-			listener, err = net.Listen("unix", server.Socket)
-			checkErr(err)
+		case serverConfig.Socket != "":
+			listener, err = net.Listen("unix", serverConfig.Socket)
+			checkErr("net.Listen", err)
 			socketPerm, err := cmd.Flags().GetUint32("socket-perm") //nolint:govet
-			checkErr(err)
-			err = os.Chmod(server.Socket, os.FileMode(socketPerm))
-			checkErr(err)
-		case server.TLSKey != "" && server.TLSCert != "":
-			cer, err := tls.LoadX509KeyPair(server.TLSCert, server.TLSKey) //nolint:govet
-			checkErr(err)
-			listener, err = tls.Listen("tcp", adr, &tls.Config{
+			checkErr("cmd.Flags().GetUint32", err)
+			err = os.Chmod(serverConfig.Socket, os.FileMode(socketPerm))
+			checkErr("os.Chmod", err)
+		case serverConfig.TLSKey != "" && serverConfig.TLSCert != "":
+			cer, err := tls.LoadX509KeyPair(serverConfig.TLSCert, serverConfig.TLSKey) //nolint:govet
+			checkErr("tls.LoadX509KeyPair", err)
+			listener, err = tls.Listen("tcp", address, &tls.Config{
 				MinVersion:   tls.VersionTLS12,
 				Certificates: []tls.Certificate{cer}},
 			)
-			checkErr(err)
+			checkErr("tls.Listen", err)
 		default:
-			listener, err = net.Listen("tcp", adr)
-			checkErr(err)
+			listener, err = net.Listen("tcp", address)
+			checkErr("net.Listen", err)
 		}
-
 		sigc := make(chan os.Signal, 1)
 		signal.Notify(sigc, os.Interrupt, syscall.SIGTERM)
 		go cleanupHandler(listener, sigc)
-
-		assetsFs := dirFS{Dir: http.Dir("frontend/dist")}
-		handler, err := fbhttp.NewHandler(imgSvc, fileCache, d.store, server, assetsFs)
-		checkErr(err)
-
-		defer listener.Close()
-
-		log.Println("Listening on", listener.Addr().String())
-		//nolint: gosec
-		if err := http.Serve(listener, handler); err != nil {
-			log.Fatal(err)
+		if !nonEmbededFS {
+			assetsFs, err := fs.Sub(assets, "dist")
+			if err != nil {
+				log.Fatal("Could not embed frontend. Does backend/cmd/dist exist? Must be built and exist first")
+			}
+			handler, err := fbhttp.NewHandler(imgSvc, fileCache, d.store, &serverConfig, assetsFs)
+			checkErr("fbhttp.NewHandler", err)
+			defer listener.Close()
+			log.Println("Listening on", listener.Addr().String())
+			//nolint: gosec
+			if err := http.Serve(listener, handler); err != nil {
+				log.Fatalf("Could not start server on port %d: %v", serverConfig.Port, err)
+			}
+		} else {
+			assetsFs := dirFS{Dir: http.Dir("frontend/dist")}
+			handler, err := fbhttp.NewHandler(imgSvc, fileCache, d.store, &serverConfig, assetsFs)
+			checkErr("fbhttp.NewHandler", err)
+			defer listener.Close()
+			log.Println("Listening on", listener.Addr().String())
+			//nolint: gosec
+			if err := http.Serve(listener, handler); err != nil {
+				log.Fatalf("Could not start server on port %d: %v", serverConfig.Port, err)
+			}
 		}
+
 	}, pythonConfig{allowNoDB: true}),
 }
 
+func StartFilebrowser() {
+	if err := rootCmd.Execute(); err != nil {
+		log.Fatal("Error starting filebrowser:", err)
+	}
+}
+
 func cleanupHandler(listener net.Listener, c chan os.Signal) { //nolint:interfacer
 	sig := <-c
 	log.Printf("Caught signal %s: shutting down.", sig)
@@ -211,217 +142,38 @@ func cleanupHandler(listener net.Listener, c chan os.Signal) { //nolint:interfac
 	os.Exit(0)
 }
 
-//nolint:gocyclo
-func getRunParams(flags *pflag.FlagSet, st *storage.Storage) *settings.Server {
-	server, err := st.Settings.GetServer()
-	checkErr(err)
-
-	if val, set := getParamB(flags, "root"); set {
-		server.Root = val
-	}
-
-	if val, set := getParamB(flags, "baseurl"); set {
-		server.BaseURL = val
-	}
-
-	if val, set := getParamB(flags, "log"); set {
-		server.Log = val
-	}
-
-	isSocketSet := false
-	isAddrSet := false
-
-	if val, set := getParamB(flags, "address"); set {
-		server.Address = val
-		isAddrSet = isAddrSet || set
-	}
-
-	if val, set := getParamB(flags, "port"); set {
-		server.Port = val
-		isAddrSet = isAddrSet || set
-	}
-
-	if val, set := getParamB(flags, "key"); set {
-		server.TLSKey = val
-		isAddrSet = isAddrSet || set
-	}
-
-	if val, set := getParamB(flags, "cert"); set {
-		server.TLSCert = val
-		isAddrSet = isAddrSet || set
-	}
-
-	if val, set := getParamB(flags, "socket"); set {
-		server.Socket = val
-		isSocketSet = isSocketSet || set
-	}
-
-	if isAddrSet && isSocketSet {
-		checkErr(errors.New("--socket flag cannot be used with --address, --port, --key nor --cert"))
-	}
-
-	// Do not use saved Socket if address was manually set.
-	if isAddrSet && server.Socket != "" {
-		server.Socket = ""
-	}
-
-	_, disableThumbnails := getParamB(flags, "disable-thumbnails")
-	server.EnableThumbnails = !disableThumbnails
-
-	_, disablePreviewResize := getParamB(flags, "disable-preview-resize")
-	server.ResizePreview = !disablePreviewResize
-
-	_, disableTypeDetectionByHeader := getParamB(flags, "disable-type-detection-by-header")
-	server.TypeDetectionByHeader = !disableTypeDetectionByHeader
-
-	_, disableExec := getParamB(flags, "disable-exec")
-	server.EnableExec = !disableExec
-
-	return server
-}
-
-// getParamB returns a parameter as a string and a boolean to tell if it is different from the default
-//
-// NOTE: we could simply bind the flags to viper and use IsSet.
-// Although there is a bug on Viper that always returns true on IsSet
-// if a flag is binded. Our alternative way is to manually check
-// the flag and then the value from env/config/gotten by viper.
-// https://github.com/spf13/viper/pull/331
-func getParamB(flags *pflag.FlagSet, key string) (string, bool) {
-	value, _ := flags.GetString(key)
-
-	// If set on Flags, use it.
-	if flags.Changed(key) {
-		return value, true
-	}
-
-	// If set through viper (env, config), return it.
-	if v.IsSet(key) {
-		return v.GetString(key), true
-	}
-
-	// Otherwise use default value on flags.
-	return value, false
-}
-
-func getParam(flags *pflag.FlagSet, key string) string {
-	val, _ := getParamB(flags, key)
-	return val
-}
-
-func setupLog(logMethod string) {
-	switch logMethod {
-	case "stdout":
-		log.SetOutput(os.Stdout)
-	case "stderr":
-		log.SetOutput(os.Stderr)
-	case "":
-		log.SetOutput(io.Discard)
-	default:
-		log.SetOutput(&lumberjack.Logger{
-			Filename:   logMethod,
-			MaxSize:    100,
-			MaxAge:     14,
-			MaxBackups: 10,
-		})
-	}
-}
-
-func quickSetup(flags *pflag.FlagSet, d pythonData) {
-	set := &settings.Settings{
-		Key:              generateKey(),
-		Signup:           false,
-		CreateUserDir:    false,
-		UserHomeBasePath: settings.DefaultUsersHomeBasePath,
-		Defaults: settings.UserDefaults{
-			Scope:       ".",
-			Locale:      "en",
-			SingleClick: false,
-			Perm: users.Permissions{
-				Admin:    false,
-				Execute:  true,
-				Create:   true,
-				Rename:   true,
-				Modify:   true,
-				Delete:   true,
-				Share:    true,
-				Download: true,
-			},
-		},
-		AuthMethod: "",
-		Branding:   settings.Branding{},
-		Commands:   nil,
-		Shell:      nil,
-		Rules:      nil,
-	}
-
-	var err error
-	if _, noauth := getParamB(flags, "noauth"); noauth {
-		set.AuthMethod = auth.MethodNoAuth
-		err = d.store.Auth.Save(&auth.NoAuth{})
+func quickSetup(d pythonData) {
+	settings.Config.Auth.Key = generateKey()
+	if settings.Config.Auth.Method == "noauth" {
+		err := d.store.Auth.Save(&auth.NoAuth{})
+		checkErr("d.store.Auth.Save", err)
 	} else {
-		set.AuthMethod = auth.MethodJSONAuth
-		err = d.store.Auth.Save(&auth.JSONAuth{})
+		settings.Config.Auth.Method = "password"
+		err := d.store.Auth.Save(&auth.JSONAuth{})
+		checkErr("d.store.Auth.Save", err)
 	}
-
-	err = d.store.Settings.Save(set)
-	checkErr(err)
-
-	ser := &settings.Server{
-		BaseURL: getParam(flags, "baseurl"),
-		Port:    getParam(flags, "port"),
-		Log:     getParam(flags, "log"),
-		TLSKey:  getParam(flags, "key"),
-		TLSCert: getParam(flags, "cert"),
-		Address: getParam(flags, "address"),
-		Root:    getParam(flags, "root"),
-	}
-	err = d.store.Settings.SaveServer(ser)
-	checkErr(err)
-
-	username := getParam(flags, "username")
-	password := getParam(flags, "password")
-
-	if password == "" {
-		password, err = users.HashPwd("admin")
-		checkErr(err)
-	}
-
-	if username == "" || password == "" {
-		log.Fatal("username and password cannot be empty during quick setup")
-	}
-
-	user := &users.User{
-		Username:     username,
-		Password:     password,
-		LockPassword: false,
-	}
-
-	set.Defaults.Apply(user)
+	err := d.store.Settings.Save(&settings.Config)
+	checkErr("d.store.Settings.Save", err)
+	err = d.store.Settings.SaveServer(&settings.Config.Server)
+	checkErr("d.store.Settings.SaveServer", err)
+	user := &users.User{}
+	settings.Config.UserDefaults.Apply(user)
+	user.Username = settings.Config.Auth.AdminUsername
+	user.Password = settings.Config.Auth.AdminPassword
 	user.Perm.Admin = true
-
+	user.Scope = "./"
+	user.DarkMode = true
+	user.ViewMode = "normal"
+	user.LockPassword = false
+	user.Perm = users.Permissions{
+		Create:   true,
+		Rename:   true,
+		Modify:   true,
+		Delete:   true,
+		Share:    true,
+		Download: true,
+		Admin:    true,
+	}
 	err = d.store.Users.Save(user)
-	checkErr(err)
-}
-
-func initConfig() {
-	if cfgFile == "" {
-		v.AddConfigPath(".")
-		v.AddConfigPath("/etc/filebrowser/")
-		v.SetConfigName(".filebrowser")
-	} else {
-		v.SetConfigFile(cfgFile)
-	}
-
-	v.SetEnvPrefix("FB")
-	v.AutomaticEnv()
-	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
-	if err := v.ReadInConfig(); err != nil {
-		if _, ok := err.(v.ConfigParseError); ok {
-			panic(err)
-		}
-		cfgFile = "No config file used"
-	} else {
-		cfgFile = "Using config file: " + v.ConfigFileUsed()
-	}
+	checkErr("d.store.Users.Save", err)
 }

backend/cmd/rule_rm.go

@@ -42,23 +42,23 @@ including 'index_end'.`,
 	},
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		i, err := strconv.Atoi(args[0])
-		checkErr(err)
+		checkErr("strconv.Atoi", err)
 		f := i
 		if len(args) == 2 { //nolint:gomnd
 			f, err = strconv.Atoi(args[1])
-			checkErr(err)
+			checkErr("strconv.Atoi", err)
 		}
 
 		user := func(u *users.User) {
 			u.Rules = append(u.Rules[:i], u.Rules[f+1:]...)
 			err := d.store.Users.Save(u)
-			checkErr(err)
+			checkErr("d.store.Users.Save", err)
 		}
 
 		global := func(s *settings.Settings) {
 			s.Rules = append(s.Rules[:i], s.Rules[f+1:]...)
 			err := d.store.Settings.Save(s)
-			checkErr(err)
+			checkErr("d.store.Settings.Save", err)
 		}
 
 		runRules(d.store, cmd, user, global)

backend/cmd/rules.go

@@ -33,7 +33,7 @@ func runRules(st *storage.Storage, cmd *cobra.Command, usersFn func(*users.User)
 	id := getUserIdentifier(cmd.Flags())
 	if id != nil {
 		user, err := st.Users.Get("", id)
-		checkErr(err)
+		checkErr("st.Users.Get", err)
 
 		if usersFn != nil {
 			usersFn(user)
@@ -44,7 +44,7 @@ func runRules(st *storage.Storage, cmd *cobra.Command, usersFn func(*users.User)
 	}
 
 	s, err := st.Settings.Get()
-	checkErr(err)
+	checkErr("st.Settings.Get", err)
 
 	if globalFn != nil {
 		globalFn(s)

backend/cmd/rules_add.go

@@ -44,13 +44,13 @@ var rulesAddCmd = &cobra.Command{
 		user := func(u *users.User) {
 			u.Rules = append(u.Rules, rule)
 			err := d.store.Users.Save(u)
-			checkErr(err)
+			checkErr("d.store.Users.Save", err)
 		}
 
 		global := func(s *settings.Settings) {
 			s.Rules = append(s.Rules, rule)
 			err := d.store.Settings.Save(s)
-			checkErr(err)
+			checkErr("d.store.Settings.Save", err)
 		}
 
 		runRules(d.store, cmd, user, global)

backend/cmd/upgrade.go

@@ -1,31 +0,0 @@
-package cmd
-
-import (
-	"github.com/spf13/cobra"
-
-	"github.com/gtsteffaniak/filebrowser/storage/bolt/importer"
-)
-
-func init() {
-	rootCmd.AddCommand(upgradeCmd)
-
-	upgradeCmd.Flags().String("old.database", "", "")
-	upgradeCmd.Flags().String("old.config", "", "")
-	_ = upgradeCmd.MarkFlagRequired("old.database")
-}
-
-var upgradeCmd = &cobra.Command{
-	Use:   "upgrade",
-	Short: "Upgrades an old configuration",
-	Long: `Upgrades an old configuration. This command DOES NOT
-import share links because they are incompatible with
-this version.`,
-	Args: cobra.NoArgs,
-	Run: func(cmd *cobra.Command, args []string) {
-		flags := cmd.Flags()
-		oldDB := mustGetString(flags, "old.database")
-		oldConf := mustGetString(flags, "old.config")
-		err := importer.Import(oldDB, oldConf, getParam(flags, "database"))
-		checkErr(err)
-	},
-}

backend/cmd/users.go

@@ -1,16 +1,13 @@
 package cmd
 
 import (
-	"errors"
 	"fmt"
 	"os"
 	"strconv"
 	"text/tabwriter"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
@@ -59,76 +56,3 @@ func parseUsernameOrID(arg string) (username string, id uint) {
 	}
 	return "", uint(id64)
 }
-
-func addUserFlags(flags *pflag.FlagSet) {
-	flags.Bool("perm.admin", false, "admin perm for users")
-	flags.Bool("perm.execute", true, "execute perm for users")
-	flags.Bool("perm.create", true, "create perm for users")
-	flags.Bool("perm.rename", true, "rename perm for users")
-	flags.Bool("perm.modify", true, "modify perm for users")
-	flags.Bool("perm.delete", true, "delete perm for users")
-	flags.Bool("perm.share", true, "share perm for users")
-	flags.Bool("perm.download", true, "download perm for users")
-	flags.String("sorting.by", "name", "sorting mode (name, size or modified)")
-	flags.Bool("sorting.asc", false, "sorting by ascending order")
-	flags.Bool("lockPassword", false, "lock password")
-	flags.StringSlice("commands", nil, "a list of the commands a user can execute")
-	flags.String("scope", ".", "scope for users")
-	flags.String("locale", "en", "locale for users")
-	flags.String("viewMode", string(users.ListViewMode), "view mode for users")
-	flags.Bool("singleClick", false, "use single clicks only")
-}
-
-func getViewMode(flags *pflag.FlagSet) users.ViewMode {
-	viewMode := users.ViewMode(mustGetString(flags, "viewMode"))
-	if viewMode != users.ListViewMode && viewMode != users.MosaicViewMode {
-		checkErr(errors.New("view mode must be \"" + string(users.ListViewMode) + "\" or \"" + string(users.MosaicViewMode) + "\""))
-	}
-	return viewMode
-}
-
-//nolint:gocyclo
-func getUserDefaults(flags *pflag.FlagSet, defaults *settings.UserDefaults, all bool) {
-	visit := func(flag *pflag.Flag) {
-		switch flag.Name {
-		case "scope":
-			defaults.Scope = mustGetString(flags, flag.Name)
-		case "locale":
-			defaults.Locale = mustGetString(flags, flag.Name)
-		case "viewMode":
-			defaults.ViewMode = getViewMode(flags)
-		case "singleClick":
-			defaults.SingleClick = mustGetBool(flags, flag.Name)
-		case "perm.admin":
-			defaults.Perm.Admin = mustGetBool(flags, flag.Name)
-		case "perm.execute":
-			defaults.Perm.Execute = mustGetBool(flags, flag.Name)
-		case "perm.create":
-			defaults.Perm.Create = mustGetBool(flags, flag.Name)
-		case "perm.rename":
-			defaults.Perm.Rename = mustGetBool(flags, flag.Name)
-		case "perm.modify":
-			defaults.Perm.Modify = mustGetBool(flags, flag.Name)
-		case "perm.delete":
-			defaults.Perm.Delete = mustGetBool(flags, flag.Name)
-		case "perm.share":
-			defaults.Perm.Share = mustGetBool(flags, flag.Name)
-		case "perm.download":
-			defaults.Perm.Download = mustGetBool(flags, flag.Name)
-		case "commands":
-			commands, err := flags.GetStringSlice(flag.Name)
-			checkErr(err)
-			defaults.Commands = commands
-		case "sorting.by":
-			defaults.Sorting.By = mustGetString(flags, flag.Name)
-		case "sorting.asc":
-			defaults.Sorting.Asc = mustGetBool(flags, flag.Name)
-		}
-	}
-
-	if all {
-		flags.VisitAll(visit)
-	} else {
-		flags.Visit(visit)
-	}
-}

backend/cmd/users_add.go

@@ -8,7 +8,6 @@ import (
 
 func init() {
 	usersCmd.AddCommand(usersAddCmd)
-	addUserFlags(usersAddCmd.Flags())
 }
 
 var usersAddCmd = &cobra.Command{
@@ -17,35 +16,25 @@ var usersAddCmd = &cobra.Command{
 	Long:  `Create a new user and add it to the database.`,
 	Args:  cobra.ExactArgs(2), //nolint:gomnd
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
-		s, err := d.store.Settings.Get()
-		checkErr(err)
-		getUserDefaults(cmd.Flags(), &s.Defaults, false)
-
-		password, err := users.HashPwd(args[1])
-		checkErr(err)
-
 		user := &users.User{
 			Username:     args[0],
-			Password:     password,
+			Password:     args[1],
 			LockPassword: mustGetBool(cmd.Flags(), "lockPassword"),
 		}
-
-		s.Defaults.Apply(user)
-
 		servSettings, err := d.store.Settings.GetServer()
-		checkErr(err)
+		checkErr("d.store.Settings.GetServer()", err)
 		// since getUserDefaults() polluted s.Defaults.Scope
 		// which makes the Scope not the one saved in the db
 		// we need the right s.Defaults.Scope here
 		s2, err := d.store.Settings.Get()
-		checkErr(err)
+		checkErr("d.store.Settings.Get()", err)
 
 		userHome, err := s2.MakeUserDir(user.Username, user.Scope, servSettings.Root)
-		checkErr(err)
+		checkErr("s2.MakeUserDir", err)
 		user.Scope = userHome
 
 		err = d.store.Users.Save(user)
-		checkErr(err)
+		checkErr("d.store.Users.Save", err)
 		printUsers([]*users.User{user})
 	}, pythonConfig{}),
 }

backend/cmd/users_export.go

@@ -16,9 +16,9 @@ path to the file where you want to write the users.`,
 	Args: jsonYamlArg,
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		list, err := d.store.Users.Gets("")
-		checkErr(err)
+		checkErr("d.store.Users.Gets", err)
 
 		err = marshal(args[0], list)
-		checkErr(err)
+		checkErr("marshal", err)
 	}, pythonConfig{}),
 }

backend/cmd/users_find.go

@@ -46,6 +46,6 @@ var findUsers = python(func(cmd *cobra.Command, args []string, d pythonData) {
 		list, err = d.store.Users.Gets("")
 	}
 
-	checkErr(err)
+	checkErr("findUsers", err)
 	printUsers(list)
 }, pythonConfig{})

backend/cmd/users_import.go

@@ -27,28 +27,28 @@ list or set it to 0.`,
 	Args: jsonYamlArg,
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		fd, err := os.Open(args[0])
-		checkErr(err)
+		checkErr("os.Open", err)
 		defer fd.Close()
 
 		list := []*users.User{}
 		err = unmarshal(args[0], &list)
-		checkErr(err)
+		checkErr("unmarshal", err)
 
 		for _, user := range list {
 			err = user.Clean("")
-			checkErr(err)
+			checkErr("Clean", err)
 		}
 
 		if mustGetBool(cmd.Flags(), "replace") {
 			oldUsers, err := d.store.Users.Gets("")
-			checkErr(err)
+			checkErr("d.store.Users.Gets", err)
 
 			err = marshal("users.backup.json", list)
-			checkErr(err)
+			checkErr("marshal users.backup.json", err)
 
 			for _, user := range oldUsers {
 				err = d.store.Users.Delete(user.ID)
-				checkErr(err)
+				checkErr("d.store.Users.Delete", err)
 			}
 		}
 
@@ -60,7 +60,8 @@ list or set it to 0.`,
 			// User exists in DB.
 			if err == nil {
 				if !overwrite {
-					checkErr(errors.New("user " + strconv.Itoa(int(user.ID)) + " is already registred"))
+					newErr := errors.New("user " + strconv.Itoa(int(user.ID)) + " is already registered")
+					checkErr("", newErr)
 				}
 
 				// If the usernames mismatch, check if there is another one in the DB
@@ -68,7 +69,8 @@ list or set it to 0.`,
 				// operation
 				if user.Username != onDB.Username {
 					if conflictuous, err := d.store.Users.Get("", user.Username); err == nil { //nolint:govet
-						checkErr(usernameConflictError(user.Username, conflictuous.ID, user.ID))
+						newErr := usernameConflictError(user.Username, conflictuous.ID, user.ID)
+						checkErr("usernameConflictError", newErr)
 					}
 				}
 			} else {
@@ -78,7 +80,7 @@ list or set it to 0.`,
 			}
 
 			err = d.store.Users.Save(user)
-			checkErr(err)
+			checkErr("d.store.Users.Save", err)
 		}
 	}, pythonConfig{}),
 }

backend/cmd/users_rm.go

@@ -25,7 +25,7 @@ var usersRmCmd = &cobra.Command{
 			err = d.store.Users.Delete(id)
 		}
 
-		checkErr(err)
+		checkErr("usersRmCmd", err)
 		fmt.Println("user deleted successfully")
 	}, pythonConfig{}),
 }

backend/cmd/users_update.go

@@ -3,16 +3,11 @@ package cmd
 import (
 	"github.com/spf13/cobra"
 
-	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 func init() {
 	usersCmd.AddCommand(usersUpdateCmd)
-
-	usersUpdateCmd.Flags().StringP("password", "p", "", "new password")
-	usersUpdateCmd.Flags().StringP("username", "u", "", "new username")
-	addUserFlags(usersUpdateCmd.Flags())
 }
 
 var usersUpdateCmd = &cobra.Command{
@@ -23,9 +18,6 @@ options you want to change.`,
 	Args: cobra.ExactArgs(1),
 	Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
 		username, id := parseUsernameOrID(args[0])
-		flags := cmd.Flags()
-		password := mustGetString(flags, "password")
-		newUsername := mustGetString(flags, "username")
 
 		var (
 			err  error
@@ -37,39 +29,10 @@ options you want to change.`,
 		} else {
 			user, err = d.store.Users.Get("", username)
 		}
-
-		checkErr(err)
-
-		defaults := settings.UserDefaults{
-			Scope:       user.Scope,
-			Locale:      user.Locale,
-			ViewMode:    user.ViewMode,
-			SingleClick: user.SingleClick,
-			Perm:        user.Perm,
-			Sorting:     user.Sorting,
-			Commands:    user.Commands,
-		}
-		getUserDefaults(flags, &defaults, false)
-		user.Scope = defaults.Scope
-		user.Locale = defaults.Locale
-		user.ViewMode = defaults.ViewMode
-		user.SingleClick = defaults.SingleClick
-		user.Perm = defaults.Perm
-		user.Commands = defaults.Commands
-		user.Sorting = defaults.Sorting
-		user.LockPassword = mustGetBool(flags, "lockPassword")
-
-		if newUsername != "" {
-			user.Username = newUsername
-		}
-
-		if password != "" {
-			user.Password, err = users.HashPwd(password)
-			checkErr(err)
-		}
+		checkErr("d.store.Users.Get", err)
 
 		err = d.store.Users.Update(user)
-		checkErr(err)
+		checkErr("d.store.Users.Update", err)
 		printUsers([]*users.User{user})
 	}, pythonConfig{}),
 }

backend/cmd/utils.go

@@ -7,45 +7,44 @@ import (
 	"log"
 	"os"
 	"path/filepath"
-	"strings"
 
 	"github.com/asdine/storm/v3"
+	"github.com/goccy/go-yaml"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
-	yaml "gopkg.in/yaml.v2"
 
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/storage"
 	"github.com/gtsteffaniak/filebrowser/storage/bolt"
 )
 
-func checkErr(err error) {
+func checkErr(source string, err error) {
 	if err != nil {
-		log.Fatal(err)
+		log.Fatalf("%s: %v", source, err)
 	}
 }
 
 func mustGetString(flags *pflag.FlagSet, flag string) string {
 	s, err := flags.GetString(flag)
-	checkErr(err)
+	checkErr("mustGetString", err)
 	return s
 }
 
 func mustGetBool(flags *pflag.FlagSet, flag string) bool {
 	b, err := flags.GetBool(flag)
-	checkErr(err)
+	checkErr("mustGetBool", err)
 	return b
 }
 
 func mustGetUint(flags *pflag.FlagSet, flag string) uint {
 	b, err := flags.GetUint(flag)
-	checkErr(err)
+	checkErr("mustGetUint", err)
 	return b
 }
 
 func generateKey() []byte {
 	k, err := settings.GenerateKey()
-	checkErr(err)
+	checkErr("generateKey", err)
 	return k
 }
 
@@ -85,8 +84,7 @@ func dbExists(path string) (bool, error) {
 func python(fn pythonFunc, cfg pythonConfig) cobraFunc {
 	return func(cmd *cobra.Command, args []string) {
 		data := pythonData{hadDB: true}
-
-		path := getParam(cmd.Flags(), "database")
+		path := settings.Config.Server.Database
 		exists, err := dbExists(path)
 
 		if err != nil {
@@ -99,17 +97,19 @@ func python(fn pythonFunc, cfg pythonConfig) cobraFunc {
 
 		data.hadDB = exists
 		db, err := storm.Open(path)
-		checkErr(err)
+		checkErr(fmt.Sprintf("storm.Open path %v", path), err)
+
 		defer db.Close()
 		data.store, err = bolt.NewStorage(db)
-		checkErr(err)
+		checkErr("bolt.NewStorage", err)
 		fn(cmd, args, data)
 	}
 }
 
 func marshal(filename string, data interface{}) error {
 	fd, err := os.Create(filename)
-	checkErr(err)
+
+	checkErr("os.Create", err)
 	defer fd.Close()
 
 	switch ext := filepath.Ext(filename); ext {
@@ -118,8 +118,8 @@ func marshal(filename string, data interface{}) error {
 		encoder.SetIndent("", "    ")
 		return encoder.Encode(data)
 	case ".yml", ".yaml": //nolint:goconst
-		encoder := yaml.NewEncoder(fd)
-		return encoder.Encode(data)
+		_, err := yaml.Marshal(fd)
+		return err
 	default:
 		return errors.New("invalid format: " + ext)
 	}
@@ -127,7 +127,7 @@ func marshal(filename string, data interface{}) error {
 
 func unmarshal(filename string, data interface{}) error {
 	fd, err := os.Open(filename)
-	checkErr(err)
+	checkErr("os.Open", err)
 	defer fd.Close()
 
 	switch ext := filepath.Ext(filename); ext {
@@ -152,42 +152,3 @@ func jsonYamlArg(cmd *cobra.Command, args []string) error {
 		return errors.New("invalid format: " + ext)
 	}
 }
-
-func cleanUpInterfaceMap(in map[interface{}]interface{}) map[string]interface{} {
-	result := make(map[string]interface{})
-	for k, v := range in {
-		result[fmt.Sprintf("%v", k)] = cleanUpMapValue(v)
-	}
-	return result
-}
-
-func cleanUpInterfaceArray(in []interface{}) []interface{} {
-	result := make([]interface{}, len(in))
-	for i, v := range in {
-		result[i] = cleanUpMapValue(v)
-	}
-	return result
-}
-
-func cleanUpMapValue(v interface{}) interface{} {
-	switch v := v.(type) {
-	case []interface{}:
-		return cleanUpInterfaceArray(v)
-	case map[interface{}]interface{}:
-		return cleanUpInterfaceMap(v)
-	default:
-		return v
-	}
-}
-
-// convertCmdStrToCmdArray checks if cmd string is blank (whitespace included)
-// then returns empty string array, else returns the splitted word array of cmd.
-// This is to ensure the result will never be []string{""}
-func convertCmdStrToCmdArray(cmd string) []string {
-	var cmdArray []string
-	trimmedCmdStr := strings.TrimSpace(cmd)
-	if trimmedCmdStr != "" {
-		cmdArray = strings.Split(trimmedCmdStr, " ")
-	}
-	return cmdArray
-}

backend/filebrowser.yaml

@@ -0,0 +1,21 @@
+server:
+  port: 80
+  baseURL:  "/"
+  root: "./srv"
+auth:
+  method: password
+  signup: false
+userDefaults:
+  darkMode: true
+  disableSettings: false
+  scope: "."
+  hideDotfiles: true
+  singleClick: false
+  permissions:
+    admin: false
+    create: false
+    rename: false
+    modify: false
+    delete: false
+    share: false
+    download: false

backend/files/conditions.go

@@ -1,28 +1,44 @@
-package search
+package files
 
 import (
+	"mime"
 	"regexp"
 	"strconv"
 	"strings"
 )
 
 var typeRegexp = regexp.MustCompile(`type:(\S+)`)
-
+var AllFiletypeOptions = []string{
+	"image",
+	"audio",
+	"archive",
+	"video",
+	"doc",
+	"dir",
+	"text",
+}
 var documentTypes = []string{
 	".word",
 	".pdf",
-	".txt",
 	".doc",
 	".docx",
 }
+var textTypes = []string{
+	".text",
+	".sh",
+	".yaml",
+	".yml",
+	".json",
+	".env",
+}
 
 var compressedFile = []string{
 	".7z",
 	".rar",
 	".zip",
 	".tar",
-	".tar.gz",
-	".tar.xz",
+	".gz",
+	".xz",
 }
 
 type SearchOptions struct {
@@ -120,3 +136,48 @@ func updateSize(given string) int {
 		return size
 	}
 }
+
+func IsMatchingType(extension string, matchType string) bool {
+	mimetype := mime.TypeByExtension(extension)
+	if strings.HasPrefix(mimetype, matchType) {
+		return true
+	}
+	switch matchType {
+	case "doc":
+		return isDoc(extension)
+	case "pdf":
+		return extension == ".pdf"
+	case "text":
+		return isText(extension)
+	case "archive":
+		return isArchive(extension)
+	}
+	return false
+}
+
+func isText(extension string) bool {
+	for _, typefile := range textTypes {
+		if extension == typefile {
+			return true
+		}
+	}
+	return false
+}
+
+func isDoc(extension string) bool {
+	for _, typefile := range documentTypes {
+		if extension == typefile {
+			return true
+		}
+	}
+	return false
+}
+
+func isArchive(extension string) bool {
+	for _, typefile := range compressedFile {
+		if extension == typefile {
+			return true
+		}
+	}
+	return false
+}

backend/files/file.go

@@ -8,33 +8,41 @@ import (
 	"encoding/hex"
 	"hash"
 	"io"
-	"log"
 	"mime"
 	"net/http"
 	"os"
-	"path"
-	"path/filepath"
+	filepath "path/filepath"
 	"strings"
+	"sync"
 	"time"
+	"unicode/utf8"
 
 	"github.com/spf13/afero"
 
 	"github.com/gtsteffaniak/filebrowser/errors"
 	"github.com/gtsteffaniak/filebrowser/rules"
+	"github.com/gtsteffaniak/filebrowser/users"
+)
+
+var (
+	bytesInMegabyte int64      = 1000000
+	pathMutexes                = make(map[string]*sync.Mutex)
+	pathMutexesMu   sync.Mutex // Mutex to protect the pathMutexes map
 )
 
 // FileInfo describes a file.
 type FileInfo struct {
 	*Listing
 	Fs        afero.Fs          `json:"-"`
-	Path      string            `json:"path"`
+	Path      string            `json:"path,omitempty"`
 	Name      string            `json:"name"`
 	Size      int64             `json:"size"`
-	Extension string            `json:"extension"`
+	Extension string            `json:"-"`
 	ModTime   time.Time         `json:"modified"`
-	Mode      os.FileMode       `json:"mode"`
-	IsDir     bool              `json:"isDir"`
-	IsSymlink bool              `json:"isSymlink"`
+	CacheTime time.Time         `json:"-"`
+	Mode      os.FileMode       `json:"-"`
+	IsDir     bool              `json:"isDir,omitempty"`
+	IsSymlink bool              `json:"isSymlink,omitempty"`
 	Type      string            `json:"type"`
 	Subtitles []string          `json:"subtitles,omitempty"`
 	Content   string            `json:"content,omitempty"`
@@ -54,6 +62,22 @@ type FileOptions struct {
 	Content    bool
 }
 
+// Sorting constants
+const (
+	SortingByName     = "name"
+	SortingBySize     = "size"
+	SortingByModified = "modified"
+)
+
+// Listing is a collection of files.
+type Listing struct {
+	Items    []*FileInfo   `json:"items"`
+	Path     string        `json:"path"`
+	NumDirs  int           `json:"numDirs"`
+	NumFiles int           `json:"numFiles"`
+	Sorting  users.Sorting `json:"sorting"`
+}
+
 // NewFileInfo creates a File object from a path and a given user. This File
 // object will be automatically filled depending on if it is a directory
 // or a file. If it's a video file, it will also detect any subtitles.
@@ -61,37 +85,131 @@ func NewFileInfo(opts FileOptions) (*FileInfo, error) {
 	if !opts.Checker.Check(opts.Path) {
 		return nil, os.ErrPermission
 	}
-
-	file, err := stat(opts)
+	file, err := stat(opts.Path, opts) // Pass opts.Path here
 	if err != nil {
 		return nil, err
 	}
-
 	if opts.Expand {
 		if file.IsDir {
-			if err := file.readListing(opts.Checker, opts.ReadHeader); err != nil { //nolint:govet
+			if err := file.readListing(opts.Path, opts.Checker, opts.ReadHeader); err != nil { //nolint:govet
 				return nil, err
 			}
 			return file, nil
 		}
-
-		err = file.detectType(opts.Modify, opts.Content, true)
+		err = file.detectType(opts.Path, opts.Modify, opts.Content, true)
 		if err != nil {
 			return nil, err
 		}
 	}
-
 	return file, err
 }
 
-func stat(opts FileOptions) (*FileInfo, error) {
-	var file *FileInfo
+func FileInfoFaster(opts FileOptions) (*FileInfo, error) {
+	// Lock access for the specific path
+	pathMutex := getMutex(opts.Path)
+	pathMutex.Lock()
+	defer pathMutex.Unlock()
+	if !opts.Checker.Check(opts.Path) {
+		return nil, os.ErrPermission
+	}
+	index := GetIndex(rootPath)
+	trimmed := strings.TrimPrefix(opts.Path, "/")
+	if trimmed == "" {
+		trimmed = "/"
+	}
+	adjustedPath := makeIndexPath(trimmed, index.Root)
+	var info FileInfo
+	info, exists := index.GetMetadataInfo(adjustedPath)
+	if exists && !opts.Content {
+		// Check if the cache time is less than 1 second
+		if time.Since(info.CacheTime) > time.Second {
+			go RefreshFileInfo(opts)
+		}
+		// refresh cache after
+		return &info, nil
+	} else {
+		// don't bother caching content
+		if opts.Content {
+			file, err := NewFileInfo(opts)
+			return file, err
+		}
+		updated := RefreshFileInfo(opts)
+		if !updated {
+			file, err := NewFileInfo(opts)
+			return file, err
+		}
+		info, exists = index.GetMetadataInfo(adjustedPath)
+		if !exists || info.Name == "" {
+			return &FileInfo{}, errors.ErrEmptyKey
+		}
+		return &info, nil
+	}
+}
 
+func RefreshFileInfo(opts FileOptions) bool {
+	if !opts.Checker.Check(opts.Path) {
+		return false
+	}
+	index := GetIndex(rootPath)
+	trimmed := strings.TrimPrefix(opts.Path, "/")
+	if trimmed == "" {
+		trimmed = "/"
+	}
+	adjustedPath := makeIndexPath(trimmed, index.Root)
+	file, err := stat(opts.Path, opts) // Pass opts.Path here
+	if err != nil {
+		return false
+	}
+	_ = file.detectType(adjustedPath, true, opts.Content, opts.ReadHeader)
+	if file.IsDir {
+		err := file.readListing(opts.Path, opts.Checker, opts.ReadHeader)
+		if err != nil {
+			return false
+		}
+		//_, exists := index.GetFileMetadata(adjustedPath)
+
+		return index.UpdateFileMetadata(adjustedPath, *file)
+	} else {
+		//_, exists := index.GetFileMetadata(adjustedPath)
+		return index.UpdateFileMetadata(adjustedPath, *file)
+	}
+}
+
+func stat(path string, opts FileOptions) (*FileInfo, error) {
+	var file *FileInfo
 	if lstaterFs, ok := opts.Fs.(afero.Lstater); ok {
-		info, _, err := lstaterFs.LstatIfPossible(opts.Path)
+		info, _, err := lstaterFs.LstatIfPossible(path)
+		if err == nil {
+			file = &FileInfo{
+				Fs:        opts.Fs,
+				Path:      opts.Path,
+				Name:      info.Name(),
+				ModTime:   info.ModTime(),
+				Mode:      info.Mode(),
+				Size:      info.Size(),
+				Extension: filepath.Ext(info.Name()),
+				Token:     opts.Token,
+			}
+			if info.IsDir() {
+				file.IsDir = true
+			}
+			if info.Mode()&os.ModeSymlink != 0 {
+				file.IsSymlink = true
+			}
+		}
+	}
+	if file == nil || file.IsSymlink {
+		info, err := opts.Fs.Stat(opts.Path)
 		if err != nil {
 			return nil, err
 		}
+
+		if file != nil && file.IsSymlink {
+			file.Size = info.Size()
+			file.IsDir = info.IsDir()
+			return file, nil
+		}
+
 		file = &FileInfo{
 			Fs:        opts.Fs,
 			Path:      opts.Path,
@@ -99,47 +217,12 @@ func stat(opts FileOptions) (*FileInfo, error) {
 			ModTime:   info.ModTime(),
 			Mode:      info.Mode(),
 			IsDir:     info.IsDir(),
-			IsSymlink: IsSymlink(info.Mode()),
 			Size:      info.Size(),
 			Extension: filepath.Ext(info.Name()),
 			Token:     opts.Token,
 		}
 	}
 
-	// regular file
-	if file != nil && !file.IsSymlink {
-		return file, nil
-	}
-
-	// fs doesn't support afero.Lstater interface or the file is a symlink
-	info, err := opts.Fs.Stat(opts.Path)
-	if err != nil {
-		// can't follow symlink
-		if file != nil && file.IsSymlink {
-			return file, nil
-		}
-		return nil, err
-	}
-
-	// set correct file size in case of symlink
-	if file != nil && file.IsSymlink {
-		file.Size = info.Size()
-		file.IsDir = info.IsDir()
-		return file, nil
-	}
-
-	file = &FileInfo{
-		Fs:        opts.Fs,
-		Path:      opts.Path,
-		Name:      info.Name(),
-		ModTime:   info.ModTime(),
-		Mode:      info.Mode(),
-		IsDir:     info.IsDir(),
-		Size:      info.Size(),
-		Extension: filepath.Ext(info.Name()),
-		Token:     opts.Token,
-	}
-
 	return file, nil
 }
 
@@ -160,19 +243,15 @@ func (i *FileInfo) Checksum(algo string) error {
 	}
 	defer reader.Close()
 
-	var h hash.Hash
+	hashFuncs := map[string]hash.Hash{
+		"md5":    md5.New(),
+		"sha1":   sha1.New(),
+		"sha256": sha256.New(),
+		"sha512": sha512.New(),
+	}
 
-	//nolint:gosec
-	switch algo {
-	case "md5":
-		h = md5.New()
-	case "sha1":
-		h = sha1.New()
-	case "sha256":
-		h = sha256.New()
-	case "sha512":
-		h = sha512.New()
-	default:
+	h, ok := hashFuncs[algo]
+	if !ok {
 		return errors.ErrInvalidOption
 	}
 
@@ -185,6 +264,7 @@ func (i *FileInfo) Checksum(algo string) error {
 	return nil
 }
 
+// RealPath gets the real path for the file, resolving symlinks if supported.
 func (i *FileInfo) RealPath() string {
 	if realPathFs, ok := i.Fs.(interface {
 		RealPath(name string) (fPath string, err error)
@@ -198,72 +278,88 @@ func (i *FileInfo) RealPath() string {
 	return i.Path
 }
 
-// TODO: use constants
-//
-//nolint:goconst
-func (i *FileInfo) detectType(modify, saveContent, readHeader bool) error {
+// addContent reads and sets content based on the file type.
+func (i *FileInfo) addContent(path string) error {
+	if !i.IsDir {
+		afs := &afero.Afero{Fs: i.Fs}
+		content, err := afs.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		stringContent := string(content)
+		if !utf8.ValidString(stringContent) {
+			return nil
+		}
+		if stringContent == "" {
+			i.Content = "empty-file-x6OlSil"
+			return nil
+		}
+		i.Content = stringContent
+	}
+	return nil
+}
+
+// detectType detects the file type.
+func (i *FileInfo) detectType(path string, modify, saveContent, readHeader bool) error {
 	if IsNamedPipe(i.Mode) {
 		i.Type = "blob"
+		if saveContent {
+			return i.addContent(path)
+		}
 		return nil
 	}
-	// failing to detect the type should not return error.
-	// imagine the situation where a file in a dir with thousands
-	// of files couldn't be opened: we'd have immediately
-	// a 500 even though it doesn't matter. So we just log it.
-
-	mimetype := mime.TypeByExtension(i.Extension)
 
 	var buffer []byte
 	if readHeader {
 		buffer = i.readFirstBytes()
-
+		mimetype := mime.TypeByExtension(i.Extension)
 		if mimetype == "" {
-			mimetype = http.DetectContentType(buffer)
+			http.DetectContentType(buffer)
 		}
 	}
 
-	switch {
-	case strings.HasPrefix(mimetype, "video"):
-		i.Type = "video"
-		i.detectSubtitles()
-		return nil
-	case strings.HasPrefix(mimetype, "audio"):
-		i.Type = "audio"
-		return nil
-	case strings.HasPrefix(mimetype, "image"):
-		i.Type = "image"
-		return nil
-	case strings.HasSuffix(mimetype, "pdf"):
-		i.Type = "pdf"
-		return nil
-	case (strings.HasPrefix(mimetype, "text") || !isBinary(buffer)) && i.Size <= 10*1024*1024: // 10 MB
-		i.Type = "text"
-
-		if !modify {
-			i.Type = "textImmutable"
+	ext := filepath.Ext(i.Name)
+	for _, fileType := range AllFiletypeOptions {
+		if IsMatchingType(ext, fileType) {
+			i.Type = fileType
 		}
 
-		if saveContent {
-			afs := &afero.Afero{Fs: i.Fs}
-			content, err := afs.ReadFile(i.Path)
-			if err != nil {
-				return err
+		switch i.Type {
+		case "text":
+			if !modify {
+				i.Type = "textImmutable"
+			}
+			if saveContent {
+				return i.addContent(path)
+			}
+		case "video":
+			parentDir := strings.TrimRight(path, i.Name)
+			i.detectSubtitles(parentDir)
+		case "doc":
+			if ext == ".pdf" {
+				i.Type = "pdf"
+				return nil
+			}
+			if saveContent {
+				return i.addContent(path)
 			}
-
-			i.Content = string(content)
 		}
-		return nil
-	default:
+	}
+
+	if i.Type == "" {
 		i.Type = "blob"
+		if saveContent {
+			return i.addContent(path)
+		}
 	}
 
 	return nil
 }
 
+// readFirstBytes reads the first bytes of the file.
 func (i *FileInfo) readFirstBytes() []byte {
 	reader, err := i.Fs.Open(i.Path)
 	if err != nil {
-		log.Print(err)
 		i.Type = "blob"
 		return nil
 	}
@@ -272,7 +368,6 @@ func (i *FileInfo) readFirstBytes() []byte {
 	buffer := make([]byte, 512) //nolint:gomnd
 	n, err := reader.Read(buffer)
 	if err != nil && err != io.EOF {
-		log.Print(err)
 		i.Type = "blob"
 		return nil
 	}
@@ -280,29 +375,43 @@ func (i *FileInfo) readFirstBytes() []byte {
 	return buffer[:n]
 }
 
-func (i *FileInfo) detectSubtitles() {
+// detectSubtitles detects subtitles for video files.
+func (i *FileInfo) detectSubtitles(parentDir string) {
 	if i.Type != "video" {
 		return
 	}
-
 	i.Subtitles = []string{}
-	ext := filepath.Ext(i.Path)
+	ext := filepath.Ext(i.Name)
+	dir, err := os.Open(parentDir)
+	if err != nil {
+		// Directory must have been deleted, remove it from the index
+		return
+	}
+	// Read the directory contents
+	files, err := dir.Readdir(-1)
+	if err != nil {
+		return
+	}
 
-	// detect multiple languages. Base*.vtt
-	// TODO: give subtitles descriptive names (lang) and track attributes
-	parentDir := strings.TrimRight(i.Path, i.Name)
-	dir, err := afero.ReadDir(i.Fs, parentDir)
-	if err == nil {
-		base := strings.TrimSuffix(i.Name, ext)
-		for _, f := range dir {
-			if !f.IsDir() && strings.HasPrefix(f.Name(), base) && strings.HasSuffix(f.Name(), ".vtt") {
-				i.Subtitles = append(i.Subtitles, path.Join(parentDir, f.Name()))
+	base := strings.TrimSuffix(i.Name, ext)
+	subtitleExts := []string{".vtt", ".txt", ".srt", ".lrc"}
+
+	for _, f := range files {
+		if f.IsDir() || !strings.HasPrefix(f.Name(), base) {
+			continue
+		}
+
+		for _, subtitleExt := range subtitleExts {
+			if strings.HasSuffix(f.Name(), subtitleExt) {
+				i.Subtitles = append(i.Subtitles, filepath.Join(parentDir, f.Name()))
+				break
 			}
 		}
 	}
 }
 
-func (i *FileInfo) readListing(checker rules.Checker, readHeader bool) error {
+// readListing reads the contents of a directory and fills the listing.
+func (i *FileInfo) readListing(path string, checker rules.Checker, readHeader bool) error {
 	afs := &afero.Afero{Fs: i.Fs}
 	dir, err := afs.ReadDir(i.Path)
 	if err != nil {
@@ -311,13 +420,14 @@ func (i *FileInfo) readListing(checker rules.Checker, readHeader bool) error {
 
 	listing := &Listing{
 		Items:    []*FileInfo{},
+		Path:     i.Path,
 		NumDirs:  0,
 		NumFiles: 0,
 	}
 
 	for _, f := range dir {
 		name := f.Name()
-		fPath := path.Join(i.Path, name)
+		fPath := filepath.Join(i.Path, name)
 
 		if !checker.Check(fPath) {
 			continue
@@ -326,8 +436,6 @@ func (i *FileInfo) readListing(checker rules.Checker, readHeader bool) error {
 		isSymlink, isInvalidLink := false, false
 		if IsSymlink(f.Mode()) {
 			isSymlink = true
-			// It's a symbolic link. We try to follow it. If it doesn't work,
-			// we stay with the link information instead of the target's.
 			info, err := i.Fs.Stat(fPath)
 			if err == nil {
 				f = info
@@ -337,15 +445,16 @@ func (i *FileInfo) readListing(checker rules.Checker, readHeader bool) error {
 		}
 
 		file := &FileInfo{
-			Fs:        i.Fs,
-			Name:      name,
-			Size:      f.Size(),
-			ModTime:   f.ModTime(),
-			Mode:      f.Mode(),
-			IsDir:     f.IsDir(),
-			IsSymlink: isSymlink,
-			Extension: filepath.Ext(name),
-			Path:      fPath,
+			Name:    name,
+			Size:    f.Size(),
+			ModTime: f.ModTime(),
+			Mode:    f.Mode(),
+		}
+		if f.IsDir() {
+			file.IsDir = true
+		}
+		if isSymlink {
+			file.IsSymlink = true
 		}
 
 		if file.IsDir {
@@ -356,7 +465,7 @@ func (i *FileInfo) readListing(checker rules.Checker, readHeader bool) error {
 			if isInvalidLink {
 				file.Type = "invalid_link"
 			} else {
-				err := file.detectType(true, false, readHeader)
+				err := file.detectType(path, true, false, readHeader)
 				if err != nil {
 					return err
 				}
@@ -369,3 +478,23 @@ func (i *FileInfo) readListing(checker rules.Checker, readHeader bool) error {
 	i.Listing = listing
 	return nil
 }
+func IsNamedPipe(mode os.FileMode) bool {
+	return mode&os.ModeNamedPipe != 0
+}
+
+func IsSymlink(mode os.FileMode) bool {
+	return mode&os.ModeSymlink != 0
+}
+
+func getMutex(path string) *sync.Mutex {
+	// Lock access to pathMutexes map
+	pathMutexesMu.Lock()
+	defer pathMutexesMu.Unlock()
+
+	// Create a mutex for the path if it doesn't exist
+	if pathMutexes[path] == nil {
+		pathMutexes[path] = &sync.Mutex{}
+	}
+
+	return pathMutexes[path]
+}

backend/files/indexing.go

@@ -0,0 +1,167 @@
+package files
+
+import (
+	"bytes"
+	"log"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gtsteffaniak/filebrowser/settings"
+)
+
+type Directory struct {
+	Metadata map[string]FileInfo
+	Files    string
+}
+type File struct {
+	Name  string
+	IsDir bool
+}
+
+type Index struct {
+	Root        string
+	Directories map[string]Directory
+	NumDirs     int
+	NumFiles    int
+	inProgress  bool
+	quickList   []File
+	LastIndexed time.Time
+	mu          sync.RWMutex
+}
+
+var (
+	rootPath     string = "/srv"
+	indexes      []*Index
+	indexesMutex sync.RWMutex
+)
+
+func InitializeIndex(intervalMinutes uint32, schedule bool) {
+	if schedule {
+		go indexingScheduler(intervalMinutes)
+	}
+}
+
+func indexingScheduler(intervalMinutes uint32) {
+	if settings.Config.Server.Root != "" {
+		rootPath = settings.Config.Server.Root
+	}
+	si := GetIndex(rootPath)
+	log.Printf("Indexing Files...")
+	log.Printf("Configured to run every %v minutes", intervalMinutes)
+	log.Printf("Indexing from root: %s", si.Root)
+	for {
+		startTime := time.Now()
+		// Set the indexing flag to indicate that indexing is in progress
+		si.resetCount()
+		// Perform the indexing operation
+		err := si.indexFiles(si.Root)
+		si.quickList = []File{}
+		// Reset the indexing flag to indicate that indexing has finished
+		si.inProgress = false
+		// Update the LastIndexed time
+		si.LastIndexed = time.Now()
+		if err != nil {
+			log.Printf("Error during indexing: %v", err)
+		}
+		if si.NumFiles+si.NumDirs > 0 {
+			timeIndexedInSeconds := int(time.Since(startTime).Seconds())
+			log.Println("Successfully indexed files.")
+			log.Printf("Time spent indexing: %v seconds\n", timeIndexedInSeconds)
+			log.Printf("Files found: %v\n", si.NumFiles)
+			log.Printf("Directories found: %v\n", si.NumDirs)
+		}
+		// Sleep for the specified interval
+		time.Sleep(time.Duration(intervalMinutes) * time.Minute)
+	}
+}
+
+// Define a function to recursively index files and directories
+func (si *Index) indexFiles(path string) error {
+	// Check if the current directory has been modified since the last indexing
+	path = strings.TrimSuffix(path, "/")
+	adjustedPath := makeIndexPath(path, si.Root)
+	dir, err := os.Open(path)
+	if err != nil {
+		// Directory must have been deleted, remove it from the index
+		si.RemoveDirectory(adjustedPath)
+	}
+	dirInfo, err := dir.Stat()
+	if err != nil {
+		dir.Close()
+		return err
+	}
+
+	// Compare the last modified time of the directory with the last indexed time
+	lastIndexed := si.LastIndexed
+	if dirInfo.ModTime().Before(lastIndexed) {
+		dir.Close()
+		return nil
+	}
+
+	// Read the directory contents
+	files, err := dir.Readdir(-1)
+	if err != nil {
+		return err
+	}
+	dir.Close()
+	si.UpdateQuickList(files)
+	si.InsertFiles(path)
+	// done separately for memory efficiency on recursion
+	si.InsertDirs(path)
+	return nil
+}
+
+func (si *Index) InsertFiles(path string) {
+	adjustedPath := makeIndexPath(path, si.Root)
+	subDirectory := Directory{}
+	buffer := bytes.Buffer{}
+
+	for _, f := range si.GetQuickList() {
+		if !f.IsDir {
+			buffer.WriteString(f.Name + ";")
+			si.UpdateCount("files")
+		}
+	}
+	// Use GetMetadataInfo and SetFileMetadata for safer read and write operations
+	subDirectory.Files = buffer.String()
+	si.SetDirectoryInfo(adjustedPath, subDirectory)
+}
+
+func (si *Index) InsertDirs(path string) {
+	adjustedPath := makeIndexPath(path, si.Root)
+	for _, f := range si.GetQuickList() {
+		if f.IsDir {
+			if _, exists := si.Directories[adjustedPath]; exists {
+				si.UpdateCount("dirs")
+				// Add or update the directory in the map
+				if adjustedPath == "/" {
+					si.SetDirectoryInfo("/"+f.Name, Directory{})
+				} else {
+					si.SetDirectoryInfo(adjustedPath+"/"+f.Name, Directory{})
+				}
+			}
+			err := si.indexFiles(path + "/" + f.Name)
+			if err != nil {
+				if err.Error() == "invalid argument" {
+					log.Printf("Could not index \"%v\": %v \n", path, "Permission Denied")
+				} else {
+					log.Printf("Could not index \"%v\": %v \n", path, err)
+				}
+			}
+		}
+	}
+}
+
+func makeIndexPath(path string, root string) string {
+	if path == root {
+		return "/"
+	}
+	adjustedPath := strings.TrimPrefix(path, root+"/")
+	adjustedPath = strings.TrimSuffix(adjustedPath, "/")
+	if adjustedPath == "" {
+		adjustedPath = "/"
+	}
+	return adjustedPath
+}

backend/files/indexing_test.go

@@ -0,0 +1,140 @@
+package files
+
+import (
+	"encoding/json"
+	"math/rand"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/gtsteffaniak/filebrowser/settings"
+)
+
+func BenchmarkFillIndex(b *testing.B) {
+	InitializeIndex(5, false)
+	si := GetIndex(settings.Config.Server.Root)
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		si.createMockData(50, 3) // 1000 dirs, 3 files per dir
+	}
+}
+
+func (si *Index) createMockData(numDirs, numFilesPerDir int) {
+	for i := 0; i < numDirs; i++ {
+		dirName := generateRandomPath(rand.Intn(3) + 1)
+		files := []File{}
+		// Append a new Directory to the slice
+		for j := 0; j < numFilesPerDir; j++ {
+			newFile := File{
+				Name:  "file-" + getRandomTerm() + getRandomExtension(),
+				IsDir: false,
+			}
+			files = append(files, newFile)
+		}
+		si.UpdateQuickListForTests(files)
+		si.InsertFiles(dirName)
+		si.InsertDirs(dirName)
+	}
+}
+
+func generateRandomPath(levels int) string {
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+	dirName := "srv"
+	for i := 0; i < levels; i++ {
+		dirName += "/" + getRandomTerm()
+	}
+	return dirName
+}
+
+func getRandomTerm() string {
+	wordbank := []string{
+		"hi", "test", "other", "name",
+		"cool", "things", "more", "items",
+	}
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	index := rand.Intn(len(wordbank))
+	return wordbank[index]
+}
+
+func getRandomExtension() string {
+	wordbank := []string{
+		".txt", ".mp3", ".mov", ".doc",
+		".mp4", ".bak", ".zip", ".jpg",
+	}
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+	index := rand.Intn(len(wordbank))
+	return wordbank[index]
+}
+
+func generateRandomSearchTerms(numTerms int) []string {
+	// Generate random search terms
+	searchTerms := make([]string, numTerms)
+	for i := 0; i < numTerms; i++ {
+		searchTerms[i] = getRandomTerm()
+	}
+	return searchTerms
+}
+
+// JSONBytesEqual compares the JSON in two byte slices.
+func JSONBytesEqual(a, b []byte) (bool, error) {
+	var j, j2 interface{}
+	if err := json.Unmarshal(a, &j); err != nil {
+		return false, err
+	}
+	if err := json.Unmarshal(b, &j2); err != nil {
+		return false, err
+	}
+	return reflect.DeepEqual(j2, j), nil
+}
+
+func TestGetIndex(t *testing.T) {
+	tests := []struct {
+		name string
+		want *map[string][]string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := GetIndex("root"); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("GetIndex() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestInitializeIndex(t *testing.T) {
+	type args struct {
+		intervalMinutes uint32
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			InitializeIndex(tt.args.intervalMinutes, false)
+		})
+	}
+}
+
+func Test_indexingScheduler(t *testing.T) {
+	type args struct {
+		intervalMinutes uint32
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			indexingScheduler(tt.args.intervalMinutes)
+		})
+	}
+}

backend/files/listing.go

@@ -1,111 +0,0 @@
-package files
-
-import (
-	"sort"
-	"strings"
-
-	"github.com/maruel/natural"
-)
-
-// Listing is a collection of files.
-type Listing struct {
-	Items    []*FileInfo `json:"items"`
-	NumDirs  int         `json:"numDirs"`
-	NumFiles int         `json:"numFiles"`
-	Sorting  Sorting     `json:"sorting"`
-}
-
-// ApplySort applies the sort order using .Order and .Sort
-//
-//nolint:goconst
-func (l Listing) ApplySort() {
-	// Check '.Order' to know how to sort
-	// TODO: use enum
-	if !l.Sorting.Asc {
-		switch l.Sorting.By {
-		case "name":
-			sort.Sort(sort.Reverse(byName(l)))
-		case "size":
-			sort.Sort(sort.Reverse(bySize(l)))
-		case "modified":
-			sort.Sort(sort.Reverse(byModified(l)))
-		default:
-			// If not one of the above, do nothing
-			return
-		}
-	} else { // If we had more Orderings we could add them here
-		switch l.Sorting.By {
-		case "name":
-			sort.Sort(byName(l))
-		case "size":
-			sort.Sort(bySize(l))
-		case "modified":
-			sort.Sort(byModified(l))
-		default:
-			sort.Sort(byName(l))
-			return
-		}
-	}
-}
-
-// Implement sorting for Listing
-type byName Listing
-type bySize Listing
-type byModified Listing
-
-// By Name
-func (l byName) Len() int {
-	return len(l.Items)
-}
-
-func (l byName) Swap(i, j int) {
-	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
-}
-
-// Treat upper and lower case equally
-func (l byName) Less(i, j int) bool {
-	if l.Items[i].IsDir && !l.Items[j].IsDir {
-		return l.Sorting.Asc
-	}
-
-	if !l.Items[i].IsDir && l.Items[j].IsDir {
-		return !l.Sorting.Asc
-	}
-
-	return natural.Less(strings.ToLower(l.Items[j].Name), strings.ToLower(l.Items[i].Name))
-}
-
-// By Size
-func (l bySize) Len() int {
-	return len(l.Items)
-}
-
-func (l bySize) Swap(i, j int) {
-	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
-}
-
-const directoryOffset = -1 << 31 // = math.MinInt32
-func (l bySize) Less(i, j int) bool {
-	iSize, jSize := l.Items[i].Size, l.Items[j].Size
-	if l.Items[i].IsDir {
-		iSize = directoryOffset + iSize
-	}
-	if l.Items[j].IsDir {
-		jSize = directoryOffset + jSize
-	}
-	return iSize < jSize
-}
-
-// By Modified
-func (l byModified) Len() int {
-	return len(l.Items)
-}
-
-func (l byModified) Swap(i, j int) {
-	l.Items[i], l.Items[j] = l.Items[j], l.Items[i]
-}
-
-func (l byModified) Less(i, j int) bool {
-	iModified, jModified := l.Items[i].ModTime, l.Items[j].ModTime
-	return iModified.Sub(jModified) < 0
-}

backend/files/search.go

@@ -0,0 +1,174 @@
+package files
+
+import (
+	"math/rand"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+var (
+	sessionInProgress sync.Map
+	maxSearchResults  = 100
+)
+
+func (si *Index) Search(search string, scope string, sourceSession string) ([]string, map[string]map[string]bool) {
+	// Remove slashes
+	scope = strings.TrimLeft(scope, "/")
+	scope = strings.TrimRight(scope, "/")
+	runningHash := generateRandomHash(4)
+	sessionInProgress.Store(sourceSession, runningHash) // Store the value in the sync.Map
+	searchOptions := ParseSearch(search)
+	fileListTypes := make(map[string]map[string]bool)
+	matching := []string{}
+	count := 0
+	for _, searchTerm := range searchOptions.Terms {
+		if searchTerm == "" {
+			continue
+		}
+		si.mu.Lock()
+		defer si.mu.Unlock()
+		for dirName, dir := range si.Directories {
+			isDir := true
+			files := strings.Split(dir.Files, ";")
+			value, found := sessionInProgress.Load(sourceSession)
+			if !found || value != runningHash {
+				return []string{}, map[string]map[string]bool{}
+			}
+			if count > maxSearchResults {
+				break
+			}
+			pathName := scopedPathNameFilter(dirName, scope, isDir)
+			if pathName == "" {
+				continue // path not matched
+			}
+			fileTypes := map[string]bool{}
+			matches, fileType := containsSearchTerm(dirName, searchTerm, *searchOptions, isDir, fileTypes)
+			if matches {
+				fileListTypes[pathName] = fileType
+				matching = append(matching, pathName)
+				count++
+			}
+			isDir = false
+			for _, file := range files {
+				if file == "" {
+					continue
+				}
+				value, found := sessionInProgress.Load(sourceSession)
+				if !found || value != runningHash {
+					return []string{}, map[string]map[string]bool{}
+				}
+
+				if count > maxSearchResults {
+					break
+				}
+				fullName := pathName + file
+				fileTypes := map[string]bool{}
+
+				matches, fileType := containsSearchTerm(fullName, searchTerm, *searchOptions, isDir, fileTypes)
+				if !matches {
+					continue
+				}
+				fileListTypes[fullName] = fileType
+				matching = append(matching, fullName)
+				count++
+			}
+		}
+	}
+	// Sort the strings based on the number of elements after splitting by "/"
+	sort.Slice(matching, func(i, j int) bool {
+		parts1 := strings.Split(matching[i], "/")
+		parts2 := strings.Split(matching[j], "/")
+		return len(parts1) < len(parts2)
+	})
+	return matching, fileListTypes
+}
+
+func scopedPathNameFilter(pathName string, scope string, isDir bool) string {
+	pathName = strings.TrimLeft(pathName, "/")
+	pathName = strings.TrimRight(pathName, "/")
+	if strings.HasPrefix(pathName, scope) || scope == "" {
+		pathName = strings.TrimPrefix(pathName, scope)
+		pathName = strings.TrimLeft(pathName, "/")
+		if isDir {
+			pathName = pathName + "/"
+		}
+	} else {
+		pathName = "" // return not matched
+	}
+	return pathName
+}
+
+func containsSearchTerm(pathName string, searchTerm string, options SearchOptions, isDir bool, fileTypes map[string]bool) (bool, map[string]bool) {
+	conditions := options.Conditions
+	path := getLastPathComponent(pathName)
+	// Convert to lowercase once
+	if !conditions["exact"] {
+		path = strings.ToLower(path)
+		searchTerm = strings.ToLower(searchTerm)
+	}
+	if strings.Contains(path, searchTerm) {
+		// Calculate fileSize only if needed
+		var fileSize int64
+		matchesAllConditions := true
+		extension := filepath.Ext(path)
+		for _, k := range AllFiletypeOptions {
+			if IsMatchingType(extension, k) {
+				fileTypes[k] = true
+			}
+		}
+		fileTypes["dir"] = isDir
+		for t, v := range conditions {
+			if t == "exact" {
+				continue
+			}
+			var matchesCondition bool
+			switch t {
+			case "larger":
+				if fileSize == 0 {
+					fileSize = getFileSize(pathName)
+				}
+				matchesCondition = fileSize > int64(options.LargerThan)*bytesInMegabyte
+			case "smaller":
+				if fileSize == 0 {
+					fileSize = getFileSize(pathName)
+				}
+				matchesCondition = fileSize < int64(options.SmallerThan)*bytesInMegabyte
+			default:
+				matchesCondition = v == fileTypes[t]
+			}
+			if !matchesCondition {
+				matchesAllConditions = false
+			}
+		}
+		return matchesAllConditions, fileTypes
+	}
+	// Clear variables and return
+	return false, map[string]bool{}
+}
+
+func getFileSize(filepath string) int64 {
+	fileInfo, err := os.Stat(rootPath + "/" + filepath)
+	if err != nil {
+		return 0
+	}
+	return fileInfo.Size()
+}
+
+func getLastPathComponent(path string) string {
+	// Use filepath.Base to extract the last component of the path
+	return filepath.Base(path)
+}
+
+func generateRandomHash(length int) string {
+	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+	result := make([]byte, length)
+	for i := range result {
+		result[i] = charset[rand.Intn(len(charset))]
+	}
+	return string(result)
+}

backend/files/search_test.go

@@ -0,0 +1,296 @@
+package files
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func BenchmarkSearchAllIndexes(b *testing.B) {
+	InitializeIndex(5, false)
+	si := GetIndex(rootPath)
+
+	si.createMockData(50, 3) // 1000 dirs, 3 files per dir
+
+	// Generate 100 random search terms
+	searchTerms := generateRandomSearchTerms(100)
+
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		// Execute the SearchAllIndexes function
+		for _, term := range searchTerms {
+			si.Search(term, "/", "test")
+		}
+	}
+}
+
+// loop over test files and compare output
+func TestParseSearch(t *testing.T) {
+	value := ParseSearch("my test search")
+	want := &SearchOptions{
+		Conditions: map[string]bool{
+			"exact": false,
+		},
+		Terms: []string{"my test search"},
+	}
+	if !reflect.DeepEqual(value, want) {
+		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
+	}
+	value = ParseSearch("case:exact my|test|search")
+	want = &SearchOptions{
+		Conditions: map[string]bool{
+			"exact": true,
+		},
+		Terms: []string{"my", "test", "search"},
+	}
+	if !reflect.DeepEqual(value, want) {
+		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
+	}
+	value = ParseSearch("type:largerThan=100 type:smallerThan=1000 test")
+	want = &SearchOptions{
+		Conditions: map[string]bool{
+			"exact":  false,
+			"larger": true,
+		},
+		Terms:       []string{"test"},
+		LargerThan:  100,
+		SmallerThan: 1000,
+	}
+	if !reflect.DeepEqual(value, want) {
+		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
+	}
+	value = ParseSearch("type:audio thisfile")
+	want = &SearchOptions{
+		Conditions: map[string]bool{
+			"exact": false,
+			"audio": true,
+		},
+		Terms: []string{"thisfile"},
+	}
+	if !reflect.DeepEqual(value, want) {
+		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
+	}
+}
+
+func TestSearchWhileIndexing(t *testing.T) {
+	InitializeIndex(5, false)
+	si := GetIndex(rootPath)
+	// Generate 100 random search terms
+	// Generate 100 random search terms
+	searchTerms := generateRandomSearchTerms(10)
+	for i := 0; i < 5; i++ {
+		// Execute the SearchAllIndexes function
+		go si.createMockData(100, 100) // 1000 dirs, 3 files per dir
+		for _, term := range searchTerms {
+			go si.Search(term, "/", "test")
+		}
+	}
+}
+
+func TestSearchIndexes(t *testing.T) {
+	index := Index{
+		Directories: map[string]Directory{
+			"test": {
+				Files: "audio1.wav;",
+			},
+			"test/path": {
+				Files: "file.txt;",
+			},
+			"new": {},
+			"new/test": {
+				Files: "audio.wav;video.mp4;video.MP4;",
+			},
+			"new/test/path": {
+				Files: "archive.zip;",
+			},
+		},
+	}
+	tests := []struct {
+		search         string
+		scope          string
+		expectedResult []string
+		expectedTypes  map[string]map[string]bool
+	}{
+		{
+			search:         "audio",
+			scope:          "/new/",
+			expectedResult: []string{"test/audio.wav"},
+			expectedTypes: map[string]map[string]bool{
+				"test/audio.wav": map[string]bool{"audio": true, "dir": false},
+			},
+		},
+		{
+			search:         "test",
+			scope:          "/",
+			expectedResult: []string{"test/", "new/test/"},
+			expectedTypes: map[string]map[string]bool{
+				"test/":     map[string]bool{"dir": true},
+				"new/test/": map[string]bool{"dir": true},
+			},
+		},
+		{
+			search:         "archive",
+			scope:          "/",
+			expectedResult: []string{"new/test/path/archive.zip"},
+			expectedTypes: map[string]map[string]bool{
+				"new/test/path/archive.zip": map[string]bool{"archive": true, "dir": false},
+			},
+		},
+		{
+			search: "video",
+			scope:  "/",
+			expectedResult: []string{
+				"new/test/video.mp4",
+				"new/test/video.MP4",
+			},
+			expectedTypes: map[string]map[string]bool{
+				"new/test/video.MP4": map[string]bool{"video": true, "dir": false},
+				"new/test/video.mp4": map[string]bool{"video": true, "dir": false},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.search, func(t *testing.T) {
+			actualResult, actualTypes := index.Search(tt.search, tt.scope, "")
+			assert.Equal(t, tt.expectedResult, actualResult)
+			if !reflect.DeepEqual(tt.expectedTypes, actualTypes) {
+				t.Fatalf("\n got:  %+v\n want: %+v", actualTypes, tt.expectedTypes)
+			}
+		})
+	}
+}
+
+func Test_scopedPathNameFilter(t *testing.T) {
+	tests := []struct {
+		name string
+		args struct {
+			pathName string
+			scope    string
+			isDir    bool // Assuming isDir should be included in args
+		}
+		want string
+	}{
+		{
+			name: "scope test",
+			args: struct {
+				pathName string
+				scope    string
+				isDir    bool
+			}{
+				pathName: "/",
+				scope:    "/",
+				isDir:    false,
+			},
+			want: "", // Update this with the expected result
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := scopedPathNameFilter(tt.args.pathName, tt.args.scope, tt.args.isDir); got != tt.want {
+				t.Errorf("scopedPathNameFilter() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_isDoc(t *testing.T) {
+	type args struct {
+		extension string
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := isDoc(tt.args.extension); got != tt.want {
+				t.Errorf("isDoc() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_getFileSize(t *testing.T) {
+	type args struct {
+		filepath string
+	}
+	tests := []struct {
+		name string
+		args args
+		want int64
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := getFileSize(tt.args.filepath); got != tt.want {
+				t.Errorf("getFileSize() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_isArchive(t *testing.T) {
+	type args struct {
+		extension string
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := isArchive(tt.args.extension); got != tt.want {
+				t.Errorf("isArchive() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_getLastPathComponent(t *testing.T) {
+	type args struct {
+		path string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := getLastPathComponent(tt.args.path); got != tt.want {
+				t.Errorf("getLastPathComponent() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_generateRandomHash(t *testing.T) {
+	type args struct {
+		length int
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := generateRandomHash(tt.args.length); got != tt.want {
+				t.Errorf("generateRandomHash() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

backend/files/sorting.go

@@ -1,7 +0,0 @@
-package files
-
-// Sorting contains a sorting order.
-type Sorting struct {
-	By  string `json:"by"`
-	Asc bool   `json:"asc"`
-}

backend/files/sync.go

@@ -0,0 +1,172 @@
+package files
+
+import (
+	"io/fs"
+	"log"
+	"time"
+
+	"github.com/gtsteffaniak/filebrowser/settings"
+)
+
+// GetFileMetadata retrieves the FileInfo from the specified directory in the index.
+func (si *Index) GetFileMetadata(adjustedPath string) (FileInfo, bool) {
+	si.mu.RLock()
+	dir, exists := si.Directories[adjustedPath]
+	si.mu.RUnlock()
+	if exists {
+		// Initialize the Metadata map if it is nil
+		if dir.Metadata == nil {
+			dir.Metadata = make(map[string]FileInfo)
+			si.SetDirectoryInfo(adjustedPath, dir)
+			return FileInfo{}, false
+		} else {
+			return dir.Metadata[adjustedPath], true
+		}
+	}
+	return FileInfo{}, false
+}
+
+// UpdateFileMetadata updates the FileInfo for the specified directory in the index.
+func (si *Index) UpdateFileMetadata(adjustedPath string, info FileInfo) bool {
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	dir, exists := si.Directories[adjustedPath]
+	if !exists {
+		// Initialize the Metadata map if it is nil
+		if dir.Metadata == nil {
+			dir.Metadata = make(map[string]FileInfo)
+		}
+		si.Directories[adjustedPath] = dir
+		// Release the read lock before calling SetFileMetadata
+	}
+	return si.SetFileMetadata(adjustedPath, info)
+}
+
+// SetFileMetadata sets the FileInfo for the specified directory in the index.
+// internal use only
+func (si *Index) SetFileMetadata(adjustedPath string, info FileInfo) bool {
+
+	_, exists := si.Directories[adjustedPath]
+	if !exists {
+		return false
+	}
+	info.CacheTime = time.Now()
+	si.Directories[adjustedPath].Metadata[adjustedPath] = info
+	return true
+}
+
+// GetMetadataInfo retrieves the FileInfo from the specified directory in the index.
+func (si *Index) GetMetadataInfo(adjustedPath string) (FileInfo, bool) {
+	si.mu.RLock()
+	dir, exists := si.Directories[adjustedPath]
+	si.mu.RUnlock()
+	if exists {
+		// Initialize the Metadata map if it is nil
+		if dir.Metadata == nil {
+			dir.Metadata = make(map[string]FileInfo)
+			si.SetDirectoryInfo(adjustedPath, dir)
+		}
+		info, metadataExists := dir.Metadata[adjustedPath]
+		return info, metadataExists
+	}
+	return FileInfo{}, false
+}
+
+// SetDirectoryInfo sets the directory information in the index.
+func (si *Index) SetDirectoryInfo(adjustedPath string, dir Directory) {
+	si.mu.Lock()
+	si.Directories[adjustedPath] = dir
+	si.mu.Unlock()
+}
+
+// SetDirectoryInfo sets the directory information in the index.
+func (si *Index) GetDirectoryInfo(adjustedPath string) (Directory, bool) {
+	si.mu.RLock()
+	dir, exists := si.Directories[adjustedPath]
+	si.mu.RUnlock()
+	if exists {
+		return dir, true
+	}
+	return Directory{}, false
+}
+
+func (si *Index) RemoveDirectory(path string) {
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	delete(si.Directories, path)
+}
+
+func (si *Index) UpdateCount(given string) {
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	if given == "files" {
+		si.NumFiles++
+	} else if given == "dirs" {
+		si.NumDirs++
+	} else {
+		log.Println("could not update unknown type: ", given)
+	}
+}
+
+func (si *Index) resetCount() {
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	si.NumDirs = 0
+	si.NumFiles = 0
+	si.inProgress = true
+}
+
+func GetIndex(root string) *Index {
+	for _, index := range indexes {
+		if index.Root == root {
+			return index
+		}
+	}
+	if settings.Config.Server.Root != "" {
+		rootPath = settings.Config.Server.Root
+	}
+	newIndex := &Index{
+		Root:        rootPath,
+		Directories: make(map[string]Directory), // Initialize the map
+		NumDirs:     0,
+		NumFiles:    0,
+		inProgress:  false,
+	}
+	indexesMutex.Lock()
+	indexes = append(indexes, newIndex)
+	indexesMutex.Unlock()
+	return newIndex
+}
+
+func (si *Index) UpdateQuickList(files []fs.FileInfo) {
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	si.quickList = []File{}
+	for _, file := range files {
+		newFile := File{
+			Name:  file.Name(),
+			IsDir: file.IsDir(),
+		}
+		si.quickList = append(si.quickList, newFile)
+	}
+}
+
+func (si *Index) UpdateQuickListForTests(files []File) {
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	si.quickList = []File{}
+	for _, file := range files {
+		newFile := File{
+			Name:  file.Name,
+			IsDir: file.IsDir,
+		}
+		si.quickList = append(si.quickList, newFile)
+	}
+}
+
+func (si *Index) GetQuickList() []File {
+	si.mu.Lock()
+	defer si.mu.Unlock()
+	newQuickList := si.quickList
+	return newQuickList
+}

backend/files/utils.go

@@ -1,59 +0,0 @@
-package files
-
-import (
-	"os"
-	"unicode/utf8"
-)
-
-func isBinary(content []byte) bool {
-	maybeStr := string(content)
-	runeCnt := utf8.RuneCount(content)
-	runeIndex := 0
-	gotRuneErrCnt := 0
-	firstRuneErrIndex := -1
-
-	const (
-		// 8 and below are control chars (e.g. backspace, null, eof, etc)
-		maxControlCharsCode = 8
-		// 0xFFFD(65533) is  the "error" Rune or "Unicode replacement character"
-		// see https://golang.org/pkg/unicode/utf8/#pkg-constants
-		unicodeReplacementChar = 0xFFFD
-	)
-
-	for _, b := range maybeStr {
-		if b <= maxControlCharsCode {
-			return true
-		}
-
-		if b == unicodeReplacementChar {
-			// if it is not the last (utf8.UTFMax - x) rune
-			if runeCnt > utf8.UTFMax && runeIndex < runeCnt-utf8.UTFMax {
-				return true
-			}
-			// else it is the last (utf8.UTFMax - x) rune
-			// there maybe Vxxx, VVxx, VVVx, thus, we may got max 3 0xFFFD rune (assume V is the byte we got)
-			// for Chinese, it can only be Vxx, VVx, we may got max 2 0xFFFD rune
-			gotRuneErrCnt++
-
-			// mark the first time
-			if firstRuneErrIndex == -1 {
-				firstRuneErrIndex = runeIndex
-			}
-		}
-		runeIndex++
-	}
-
-	// if last (utf8.UTFMax - x ) rune has the "error" Rune, but not all
-	if firstRuneErrIndex != -1 && gotRuneErrCnt != runeCnt-firstRuneErrIndex {
-		return true
-	}
-	return false
-}
-
-func IsNamedPipe(mode os.FileMode) bool {
-	return mode&os.ModeNamedPipe != 0
-}
-
-func IsSymlink(mode os.FileMode) bool {
-	return mode&os.ModeSymlink != 0
-}

backend/frontend/package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "frontend",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

backend/go.mod

@@ -1,32 +1,27 @@
 module github.com/gtsteffaniak/filebrowser
 
-go 1.20
+go 1.22.5
 
 require (
 	github.com/asdine/storm/v3 v3.2.1
 	github.com/disintegration/imaging v1.6.2
 	github.com/dsoprea/go-exif/v3 v3.0.1
 	github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568
+	github.com/goccy/go-yaml v1.12.0
 	github.com/golang-jwt/jwt/v4 v4.5.0
-	github.com/gorilla/mux v1.8.0
-	github.com/gorilla/websocket v1.5.0
-	github.com/maruel/natural v1.1.0
+	github.com/google/go-cmp v0.6.0
+	github.com/gorilla/mux v1.8.1
 	github.com/marusama/semaphore/v2 v2.5.0
 	github.com/mholt/archiver/v3 v3.5.1
-	github.com/pelletier/go-toml/v2 v2.0.9
-	github.com/shirou/gopsutil/v3 v3.23.7
-	github.com/spf13/afero v1.9.5
-	github.com/spf13/cobra v1.7.0
+	github.com/shirou/gopsutil/v3 v3.24.5
+	github.com/spf13/afero v1.11.0
+	github.com/spf13/cobra v1.8.1
 	github.com/spf13/pflag v1.0.5
-	github.com/spf13/viper v1.16.0
-	github.com/stretchr/testify v1.8.4
+	github.com/stretchr/testify v1.9.0
 	github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce
-	go.etcd.io/bbolt v1.3.7
-	golang.org/x/crypto v0.12.0
-	golang.org/x/image v0.11.0
-	golang.org/x/text v0.12.0
-	gopkg.in/natefinch/lumberjack.v2 v2.2.1
-	gopkg.in/yaml.v2 v2.4.0
+	golang.org/x/crypto v0.25.0
+	golang.org/x/image v0.18.0
+	golang.org/x/text v0.16.0
 )
 
 require (
@@ -35,29 +30,27 @@ require (
 	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
 	github.com/dsoprea/go-logging v0.0.0-20200710184922-b02d349568dd // indirect
 	github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349 // indirect
-	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/fatih/color v1.10.0 // indirect
 	github.com/go-errors/errors v1.4.2 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/golang/geo v0.0.0-20210211234256-740aa86cb551 // indirect
 	github.com/golang/snappy v0.0.2 // indirect
-	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/klauspost/compress v1.11.4 // indirect
 	github.com/klauspost/pgzip v1.2.5 // indirect
-	github.com/magiconair/properties v1.8.7 // indirect
-	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mattn/go-colorable v0.1.8 // indirect
+	github.com/mattn/go-isatty v0.0.12 // indirect
 	github.com/nwaples/rardecode v1.1.0 // indirect
 	github.com/pierrec/lz4/v4 v4.1.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
-	github.com/spf13/cast v1.5.1 // indirect
-	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/subosito/gotenv v1.4.2 // indirect
 	github.com/ulikunitz/xz v0.5.9 // indirect
 	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
-	github.com/yusufpapurcu/wmi v1.2.3 // indirect
-	golang.org/x/net v0.10.0 // indirect
-	golang.org/x/sys v0.11.0 // indirect
-	gopkg.in/ini.v1 v1.67.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+	go.etcd.io/bbolt v1.3.4 // indirect
+	golang.org/x/net v0.21.0 // indirect
+	golang.org/x/sys v0.22.0 // indirect
+	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

backend/go.sum

@@ -1,43 +1,3 @@
-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.44.3/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 v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
-cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
-cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY=
-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/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=
-cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-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/DataDog/zstd v1.4.1 h1:3oxKN3wbHibqx897utPC2LTQU4J+IHWWJO+glkAkpFM=
 github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
 github.com/Sereal/Sereal v0.0.0-20190618215532-0b8ac451a863 h1:BRrxwOZBolJN4gIwvZMJY1tzqBvQgpaZiQRuIDD40jM=
@@ -46,16 +6,7 @@ github.com/andybalholm/brotli v1.0.1 h1:KqhlKozYbRtJvsPrrEeXcO+N2l6NYT5A2QAFmSUL
 github.com/andybalholm/brotli v1.0.1/go.mod h1:loMXtMfwqflxFJPmdbJO0a3KNoPuLBgiu3qAvBg8x/Y=
 github.com/asdine/storm/v3 v3.2.1 h1:I5AqhkPK6nBZ/qJXySdI7ot5BlXSZ7qvDY1zAn5ZJac=
 github.com/asdine/storm/v3 v3.2.1/go.mod h1:LEpXwGt4pIqrE/XcTvCnZHT5MgZCV6Ub9q7yQzOFWr0=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-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/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c=
@@ -80,182 +31,88 @@ github.com/dsoprea/go-utility/v2 v2.0.0-20221003142440-7a1927d49d9d/go.mod h1:LV
 github.com/dsoprea/go-utility/v2 v2.0.0-20221003160719-7bc88537c05e/go.mod h1:VZ7cB0pTjm1ADBWhJUOHESu4ZYy9JN+ZPqjfiW09EPU=
 github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349 h1:DilThiXje0z+3UQ5YjYiSRRzVdtamFpvBQXKwMglWqw=
 github.com/dsoprea/go-utility/v2 v2.0.0-20221003172846-a3e1774ef349/go.mod h1:4GC5sXji84i/p+irqghpPFZBF8tRN/Q7+700G0/DLe8=
-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/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
+github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BHsljHzVlRcyQhjrss6TZTdY2VfCqZPbv5k3iBFa2ZQ=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
-github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY=
-github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
-github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
 github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
 github.com/go-errors/errors v1.0.2/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs=
 github.com/go-errors/errors v1.1.1/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs=
 github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
 github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
-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-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
+github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
+github.com/goccy/go-yaml v1.12.0 h1:/1WHjnMsI1dlIBQutrvSMGZRQufVO3asrHfTwfACoPM=
+github.com/goccy/go-yaml v1.12.0/go.mod h1:wKnAMd44+9JAAnGQpWVEgBzGt3YuTaQ4uXoHvE4m7WU=
 github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg=
 github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0=
 github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
 github.com/golang/geo v0.0.0-20200319012246-673a6f80352d/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
 github.com/golang/geo v0.0.0-20210211234256-740aa86cb551 h1:gtexQ/VGyN+VVFRXSFiguSNcXmS6rkKT+X7FdIrTtfo=
 github.com/golang/geo v0.0.0-20210211234256-740aa86cb551/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI=
-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.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.2 h1:aeE13tS0IiQgFjYdoL8qN3K1N2bXXtI6Vi51/y7BpMw=
 github.com/golang/snappy v0.0.2/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-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.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-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/martian/v3 v3.1.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-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-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/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g=
-github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
-github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
-github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
-github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-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/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
-github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4=
-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/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/klauspost/compress v1.4.1/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
 github.com/klauspost/compress v1.11.4 h1:kz40R/YWls3iqT9zX9AHN3WoVsrAWVyui5sxuLqiXqU=
 github.com/klauspost/compress v1.11.4/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/cpuid v1.2.0/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/pgzip v1.2.5 h1:qnWYvvKqedOF2ulHpMG72XQol4ILEJ8k2wwRl/Km8oE=
 github.com/klauspost/pgzip v1.2.5/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs=
-github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 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/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I=
-github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
-github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/maruel/natural v1.1.0 h1:2z1NgP/Vae+gYrtC0VuvrTJ6U35OuyUqDdfluLqMWuQ=
-github.com/maruel/natural v1.1.0/go.mod h1:eFVhYCcUOfZFxXoDZam8Ktya72wa79fNC3lc/leA0DQ=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/marusama/semaphore/v2 v2.5.0 h1:o/1QJD9DBYOWRnDhPwDVAXQn6mQYD0gZaS1Tpx6DJGM=
 github.com/marusama/semaphore/v2 v2.5.0/go.mod h1:z9nMiNUekt/LTpTUQdpp+4sJeYqUGpwMHfW0Z8V8fnQ=
+github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mholt/archiver/v3 v3.5.1 h1:rDjOBX9JSF5BvoJGvjqK479aL70qh9DIpZCl+k7Clwo=
 github.com/mholt/archiver/v3 v3.5.1/go.mod h1:e3dqJ7H78uzsRSEACH1joayhuSyhnonssnDhppzS1L4=
-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/nwaples/rardecode v1.1.0 h1:vSxaY8vQhOcVr4mm5e8XllHWTiM4JF507A0Katqw7MQ=
 github.com/nwaples/rardecode v1.1.0/go.mod h1:5DzqNKiOdpKKBH87u8VlvAnPZMXcGRhxWkRpHbbfGS0=
-github.com/pelletier/go-toml/v2 v2.0.9 h1:uH2qQXheeefCCkuBBSLi7jCiSmj3VRh2+Goq2N7Xxu0=
-github.com/pelletier/go-toml/v2 v2.0.9/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
 github.com/pierrec/lz4/v4 v4.1.2 h1:qvY3YFXRQE/XB8MlLzJH7mSzBs74eA2gg52YTk6jUPM=
 github.com/pierrec/lz4/v4 v4.1.2/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw=
 github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
-github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/shirou/gopsutil/v3 v3.23.7 h1:C+fHO8hfIppoJ1WdsVm1RoI0RwXoNdfTK7yWXV0wVj4=
-github.com/shirou/gopsutil/v3 v3.23.7/go.mod h1:c4gnmoRC0hQuaLqvxnx1//VXQ0Ms/X9UnJF8pddY5z4=
-github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
-github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
-github.com/spf13/afero v1.9.5 h1:stMpOSZFs//0Lv29HduCmli3GUfpFoF3Y1Q/aXj/wVM=
-github.com/spf13/afero v1.9.5/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ=
-github.com/spf13/cast v1.5.1 h1:R+kOtfhWQE6TVQzY+4D7wJLBgkdVasCEFxSUBYBYIlA=
-github.com/spf13/cast v1.5.1/go.mod h1:b9PdjNptOpzXr7Rq1q9gJML/2cdGQAo69NKzQ10KN48=
-github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
-github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
-github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
-github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
+github.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI=
+github.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk=
+github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
+github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
+github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
+github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.16.0 h1:rGGH0XDZhdUOryiDWjmIvUSWpbNqisK8Wk0Vyefw8hc=
-github.com/spf13/viper v1.16.0/go.mod h1:yg78JgCJcbrQOvV9YLXgkLaZqUidkY9K+Dd1FofRzQg=
-github.com/stretchr/objx v0.1.0/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/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-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.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/subosito/gotenv v1.4.2 h1:X1TuBLAMDFbaTAChgCBLu3DU3UPyELpnF2jjJ2cz/S8=
-github.com/subosito/gotenv v1.4.2/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0=
-github.com/tklauser/go-sysconf v0.3.11/go.mod h1:GqXfhXY3kiPa0nAXPDIQIWzJbMCB7AmcWpGR8lSZfqI=
-github.com/tklauser/numcpus v0.6.0/go.mod h1:FEZLMke0lhOUG6w2JadTzp0a+Nl8PF/GFkQ5UVIcaL4=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce h1:fb190+cK2Xz/dvi9Hv8eCYJYvIGUTN2/KLq1pT6CjEc=
 github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce/go.mod h1:o8v6yHRoik09Xen7gje4m9ERNah1d1PPsVq1VEx9vE4=
 github.com/ulikunitz/xz v0.5.8/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
@@ -265,362 +122,59 @@ github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaU
 github.com/vmihailenco/msgpack v4.0.4+incompatible/go.mod h1:fy3FlTQTDXWkZ7Bh6AcGMlsjHatGryHQYUTf1ShIgkk=
 github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 h1:nIPpBwaJSVYIxUFsDv3M8ofmx9yWTog9BfvIu0q41lo=
 github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos=
-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/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw=
-github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+go.etcd.io/bbolt v1.3.4 h1:hi1bXHMVrlQh6WwxAy+qZCV/SYIlqo+Ushwdpa4tAKg=
 go.etcd.io/bbolt v1.3.4/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
-go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ=
-go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
-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.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
 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-20190605123033-f99c8df09eb5/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-20210421170649-83a5a9bb288b/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-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
-golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
-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/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/crypto v0.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
+golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
 golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/image v0.11.0 h1:ds2RoQvBvYTiJkwpSFDwCcDFNX7DqjL2WsUgTNk0Ooo=
-golang.org/x/image v0.11.0/go.mod h1:bglhjqbqVuEb9e9+eNR45Jfu7D+T4Qan+NhQk8Ck2P8=
-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/lint v0.0.0-20201208152925-83fdc39ff7b5/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/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.4.1/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/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/image v0.18.0 h1:jGzIakQa/ZXI1I0Fxvaa9W7yP25TqT6cHIHn+6CqvSQ=
+golang.org/x/image v0.18.0/go.mod h1:4yyo5vMFQjVjUcVk4jEQcU9MGy/rulF5WvUILseCM2E=
 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-20191105084925-a882066a44e0/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-20200320220750-118fecf932d8/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-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-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.0.0-20221002022538-bcab6841153b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-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-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-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-20201207232520-09787c993a3a/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/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
 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-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-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-20200116001909-b77594299b42/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-20200905004654-be1d3432aa8f/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-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/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-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
-golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 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/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.4/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.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
-golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-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/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
+golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 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-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-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-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-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
-golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
-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/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.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
-google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
-google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
-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=
+golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 h1:H2TDz8ibqkAF6YGhCdN3jS9O0/s90v0rJh3X/OLHEUk=
+golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
 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/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c=
 google.golang.org/appengine v1.6.7/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-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-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.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
-google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
-google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-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.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 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-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
-gopkg.in/ini.v1 v1.67.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/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0/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=
-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=

backend/http/auth.go

@@ -2,6 +2,7 @@ package http
 
 import (
 	"encoding/json"
+	"fmt"
 	"log"
 	"net/http"
 	"os"
@@ -12,27 +13,12 @@ import (
 	"github.com/golang-jwt/jwt/v4/request"
 
 	"github.com/gtsteffaniak/filebrowser/errors"
+	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
-const (
-	TokenExpirationTime = time.Hour * 2
-)
-
-type userInfo struct {
-	ID           uint              `json:"id"`
-	Locale       string            `json:"locale"`
-	ViewMode     users.ViewMode    `json:"viewMode"`
-	SingleClick  bool              `json:"singleClick"`
-	Perm         users.Permissions `json:"perm"`
-	Commands     []string          `json:"commands"`
-	LockPassword bool              `json:"lockPassword"`
-	HideDotfiles bool              `json:"hideDotfiles"`
-	DateFormat   bool              `json:"dateFormat"`
-}
-
 type authToken struct {
-	User userInfo `json:"user"`
+	User users.User `json:"user"`
 	jwt.RegisteredClaims
 }
 
@@ -66,7 +52,7 @@ func (e extractor) ExtractToken(r *http.Request) (string, error) {
 func withUser(fn handleFunc) handleFunc {
 	return func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
 		keyFunc := func(token *jwt.Token) (interface{}, error) {
-			return d.settings.Key, nil
+			return d.settings.Auth.Key, nil
 		}
 
 		var tk authToken
@@ -102,12 +88,12 @@ func withAdmin(fn handleFunc) handleFunc {
 }
 
 var loginHandler = func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	auther, err := d.store.Auth.Get(d.settings.AuthMethod)
+	auther, err := d.store.Auth.Get(d.settings.Auth.Method)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
 
-	user, err := auther.Auth(r, d.store.Users, d.settings, d.server)
+	user, err := auther.Auth(r, d.store.Users)
 	if err == os.ErrPermission {
 		return http.StatusForbidden, nil
 	} else if err != nil {
@@ -123,7 +109,7 @@ type signupBody struct {
 }
 
 var signupHandler = func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	if !d.settings.Signup {
+	if !settings.Config.Auth.Signup {
 		return http.StatusMethodNotAllowed, nil
 	}
 
@@ -143,17 +129,9 @@ var signupHandler = func(w http.ResponseWriter, r *http.Request, d *data) (int,
 
 	user := &users.User{
 		Username: info.Username,
+		Password: info.Password,
 	}
-
-	d.settings.Defaults.Apply(user)
-
-	pwd, err := users.HashPwd(info.Password)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-
-	user.Password = pwd
-
+	settings.Config.UserDefaults.Apply(user)
 	userHome, err := d.settings.MakeUserDir(user.Username, user.Scope, d.server.Root)
 	if err != nil {
 		log.Printf("create user: failed to mkdir user home dir: [%s]", userHome)
@@ -161,7 +139,7 @@ var signupHandler = func(w http.ResponseWriter, r *http.Request, d *data) (int,
 	}
 	user.Scope = userHome
 	log.Printf("new user: %s, home dir: [%s].", user.Username, userHome)
-
+	settings.Config.UserDefaults.Apply(user)
 	err = d.store.Users.Save(user)
 	if err == errors.ErrExist {
 		return http.StatusConflict, err
@@ -177,27 +155,22 @@ var renewHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data
 })
 
 func printToken(w http.ResponseWriter, _ *http.Request, d *data, user *users.User) (int, error) {
+	duration, err := time.ParseDuration(settings.Config.Auth.TokenExpirationTime)
+	if err != nil {
+		fmt.Println("Error parsing duration:", err)
+		duration = time.Hour * 2
+	}
 	claims := &authToken{
-		User: userInfo{
-			ID:           user.ID,
-			Locale:       user.Locale,
-			ViewMode:     user.ViewMode,
-			SingleClick:  user.SingleClick,
-			Perm:         user.Perm,
-			LockPassword: user.LockPassword,
-			Commands:     user.Commands,
-			HideDotfiles: user.HideDotfiles,
-			DateFormat:   user.DateFormat,
-		},
+		User: *user,
 		RegisteredClaims: jwt.RegisteredClaims{
 			IssuedAt:  jwt.NewNumericDate(time.Now()),
-			ExpiresAt: jwt.NewNumericDate(time.Now().Add(TokenExpirationTime)),
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(duration)),
 			Issuer:    "File Browser",
 		},
 	}
 
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
-	signed, err := token.SignedString(d.settings.Key)
+	signed, err := token.SignedString(d.settings.Auth.Key)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}

backend/http/commands.go

@@ -1,111 +0,0 @@
-package http
-
-import (
-	"bufio"
-	"io"
-	"log"
-	"net/http"
-	"os/exec"
-	"strings"
-	"time"
-
-	"github.com/gorilla/websocket"
-
-	"github.com/gtsteffaniak/filebrowser/runner"
-)
-
-const (
-	WSWriteDeadline = 10 * time.Second
-)
-
-var upgrader = websocket.Upgrader{
-	ReadBufferSize:  1024,
-	WriteBufferSize: 1024,
-}
-
-var (
-	cmdNotAllowed = []byte("Command not allowed.")
-)
-
-//nolint:unparam
-func wsErr(ws *websocket.Conn, r *http.Request, status int, err error) {
-	txt := http.StatusText(status)
-	if err != nil || status >= 400 {
-		log.Printf("%s: %v %s %v", r.URL.Path, status, r.RemoteAddr, err)
-	}
-	if err := ws.WriteControl(websocket.CloseInternalServerErr, []byte(txt), time.Now().Add(WSWriteDeadline)); err != nil {
-		log.Print(err)
-	}
-}
-
-var commandsHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-	defer conn.Close()
-
-	var raw string
-
-	for {
-		_, msg, err := conn.ReadMessage() //nolint:govet
-		if err != nil {
-			wsErr(conn, r, http.StatusInternalServerError, err)
-			return 0, nil
-		}
-
-		raw = strings.TrimSpace(string(msg))
-		if raw != "" {
-			break
-		}
-	}
-
-	command, err := runner.ParseCommand(d.settings, raw)
-	if err != nil {
-		if err := conn.WriteMessage(websocket.TextMessage, []byte(err.Error())); err != nil { //nolint:govet
-			wsErr(conn, r, http.StatusInternalServerError, err)
-		}
-		return 0, nil
-	}
-
-	if !d.server.EnableExec || !d.user.CanExecute(command[0]) {
-		if err := conn.WriteMessage(websocket.TextMessage, cmdNotAllowed); err != nil { //nolint:govet
-			wsErr(conn, r, http.StatusInternalServerError, err)
-		}
-
-		return 0, nil
-	}
-
-	cmd := exec.Command(command[0], command[1:]...) //nolint:gosec
-	cmd.Dir = d.user.FullPath(r.URL.Path)
-
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		wsErr(conn, r, http.StatusInternalServerError, err)
-		return 0, nil
-	}
-
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		wsErr(conn, r, http.StatusInternalServerError, err)
-		return 0, nil
-	}
-
-	if err := cmd.Start(); err != nil {
-		wsErr(conn, r, http.StatusInternalServerError, err)
-		return 0, nil
-	}
-
-	s := bufio.NewScanner(io.MultiReader(stdout, stderr))
-	for s.Scan() {
-		if err := conn.WriteMessage(websocket.TextMessage, s.Bytes()); err != nil {
-			log.Print(err)
-		}
-	}
-
-	if err := cmd.Wait(); err != nil {
-		wsErr(conn, r, http.StatusInternalServerError, err)
-	}
-
-	return 0, nil
-})

backend/http/data.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/tomasen/realip"
 
-	"github.com/gtsteffaniak/filebrowser/rules"
 	"github.com/gtsteffaniak/filebrowser/runner"
 	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/storage"
@@ -27,9 +26,6 @@ type data struct {
 
 // Check implements rules.Checker.
 func (d *data) Check(path string) bool {
-	if d.user.HideDotfiles && rules.MatchHidden(path) {
-		return false
-	}
 
 	allow := true
 	for _, rule := range d.settings.Rules {
@@ -37,7 +33,6 @@ func (d *data) Check(path string) bool {
 			allow = rule.Allow
 		}
 	}
-
 	for _, rule := range d.user.Rules {
 		if rule.Matches(path) {
 			allow = rule.Allow

backend/http/http.go

@@ -32,58 +32,45 @@ func NewHandler(
 		})
 	})
 	index, static := getStaticHandlers(store, server, assetsFs)
-
 	// NOTE: This fixes the issue where it would redirect if people did not put a
 	// trailing slash in the end. I hate this decision since this allows some awful
 	// URLs https://www.gorillatoolkit.org/pkg/mux#Router.SkipClean
 	r = r.SkipClean(true)
-
 	monkey := func(fn handleFunc, prefix string) http.Handler {
 		return handle(fn, prefix, store, server)
 	}
-
 	r.HandleFunc("/health", healthHandler)
 	r.PathPrefix("/static").Handler(static)
 	r.NotFoundHandler = index
-
 	api := r.PathPrefix("/api").Subrouter()
-
 	api.Handle("/login", monkey(loginHandler, ""))
 	api.Handle("/signup", monkey(signupHandler, ""))
 	api.Handle("/renew", monkey(renewHandler, ""))
-
 	users := api.PathPrefix("/users").Subrouter()
 	users.Handle("", monkey(usersGetHandler, "")).Methods("GET")
 	users.Handle("", monkey(userPostHandler, "")).Methods("POST")
 	users.Handle("/{id:[0-9]+}", monkey(userPutHandler, "")).Methods("PUT")
 	users.Handle("/{id:[0-9]+}", monkey(userGetHandler, "")).Methods("GET")
 	users.Handle("/{id:[0-9]+}", monkey(userDeleteHandler, "")).Methods("DELETE")
-
 	api.PathPrefix("/resources").Handler(monkey(resourceGetHandler, "/api/resources")).Methods("GET")
 	api.PathPrefix("/resources").Handler(monkey(resourceDeleteHandler(fileCache), "/api/resources")).Methods("DELETE")
 	api.PathPrefix("/resources").Handler(monkey(resourcePostHandler(fileCache), "/api/resources")).Methods("POST")
 	api.PathPrefix("/resources").Handler(monkey(resourcePutHandler, "/api/resources")).Methods("PUT")
 	api.PathPrefix("/resources").Handler(monkey(resourcePatchHandler(fileCache), "/api/resources")).Methods("PATCH")
-
 	api.PathPrefix("/usage").Handler(monkey(diskUsage, "/api/usage")).Methods("GET")
-
 	api.Path("/shares").Handler(monkey(shareListHandler, "/api/shares")).Methods("GET")
 	api.PathPrefix("/share").Handler(monkey(shareGetsHandler, "/api/share")).Methods("GET")
 	api.PathPrefix("/share").Handler(monkey(sharePostHandler, "/api/share")).Methods("POST")
 	api.PathPrefix("/share").Handler(monkey(shareDeleteHandler, "/api/share")).Methods("DELETE")
-
 	api.Handle("/settings", monkey(settingsGetHandler, "")).Methods("GET")
 	api.Handle("/settings", monkey(settingsPutHandler, "")).Methods("PUT")
-
 	api.PathPrefix("/raw").Handler(monkey(rawHandler, "/api/raw")).Methods("GET")
 	api.PathPrefix("/preview/{size}/{path:.*}").
 		Handler(monkey(previewHandler(imgSvc, fileCache, server.EnableThumbnails, server.ResizePreview), "/api/preview")).Methods("GET")
-	api.PathPrefix("/command").Handler(monkey(commandsHandler, "/api/command")).Methods("GET")
 	api.PathPrefix("/search").Handler(monkey(searchHandler, "/api/search")).Methods("GET")
-
 	public := api.PathPrefix("/public").Subrouter()
+	public.Handle("/publicUser", monkey(publicUserGetHandler, "")).Methods("GET")
 	public.PathPrefix("/dl").Handler(monkey(publicDlHandler, "/api/public/dl/")).Methods("GET")
 	public.PathPrefix("/share").Handler(monkey(publicShareHandler, "/api/public/share/")).Methods("GET")
-
 	return stripPrefix(server.BaseURL, r), nil
 }

backend/http/preview.go

@@ -45,7 +45,7 @@ func previewHandler(imgSvc ImgService, fileCache FileCache, enableThumbnails, re
 			return http.StatusBadRequest, err
 		}
 
-		file, err := files.NewFileInfo(files.FileOptions{
+		file, err := files.FileInfoFaster(files.FileOptions{
 			Fs:         d.user.Fs,
 			Path:       "/" + vars["path"],
 			Modify:     d.user.Perm.Modify,
@@ -53,10 +53,10 @@ func previewHandler(imgSvc ImgService, fileCache FileCache, enableThumbnails, re
 			ReadHeader: d.server.TypeDetectionByHeader,
 			Checker:    d,
 		})
+
 		if err != nil {
 			return errToStatus(err), err
 		}
-
 		setContentDisposition(w, r, file)
 
 		switch file.Type {
@@ -81,7 +81,6 @@ func handleImagePreview(
 		(previewSize == PreviewSizeThumb && !enableThumbnails) {
 		return rawFileHandler(w, r, file)
 	}
-
 	format, err := imgSvc.FormatFromExtension(file.Extension)
 	// Unsupported extensions directly return the raw data
 	if err == img.ErrUnsupportedFormat || format == img.FormatGif {

backend/http/public.go

@@ -12,34 +12,41 @@ import (
 	"golang.org/x/crypto/bcrypt"
 
 	"github.com/gtsteffaniak/filebrowser/files"
+	"github.com/gtsteffaniak/filebrowser/settings"
 	"github.com/gtsteffaniak/filebrowser/share"
+	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 var withHashFile = func(fn handleFunc) handleFunc {
 	return func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-		id, ifPath := ifPathWithName(r)
+		id, path := ifPathWithName(r)
 		link, err := d.store.Share.GetByHash(id)
 		if err != nil {
 			return errToStatus(err), err
 		}
-
-		status, err := authenticateShareRequest(r, link)
-		if status != 0 || err != nil {
-			return status, err
+		if link.Hash != "" {
+			status, err := authenticateShareRequest(r, link)
+			if status != 0 || err != nil {
+				return status, err
+			}
 		}
-
-		user, err := d.store.Users.Get(d.server.Root, link.UserID)
-		if err != nil {
-			return errToStatus(err), err
+		d.user = &users.PublicUser
+		if path == "/" {
+			path = link.Path
+		} else if strings.HasPrefix("/"+path, link.Path) {
+			path = "/" + path
+		} else {
+			path = link.Path + "/" + path
 		}
-
-		d.user = user
-
-		file, err := files.NewFileInfo(files.FileOptions{
-			Fs:         d.user.Fs,
-			Path:       link.Path,
+		sharePath := settings.Config.Server.Root + path
+		lastComponent := filepath.Base(sharePath)
+		basePath := filepath.Dir(sharePath)
+		fsPath := afero.NewBasePathFs(afero.NewOsFs(), basePath)
+		file, err := files.FileInfoFaster(files.FileOptions{
+			Fs:         fsPath,
+			Path:       lastComponent,
 			Modify:     d.user.Perm.Modify,
-			Expand:     false,
+			Expand:     true,
 			ReadHeader: d.server.TypeDetectionByHeader,
 			Checker:    d,
 			Token:      link.Token,
@@ -47,65 +54,37 @@ var withHashFile = func(fn handleFunc) handleFunc {
 		if err != nil {
 			return errToStatus(err), err
 		}
-
-		// share base path
-		basePath := link.Path
-
-		// file relative path
-		filePath := ""
-
-		if file.IsDir {
-			basePath = filepath.Dir(basePath)
-			filePath = ifPath
-		}
-
-		// set fs root to the shared file/folder
-		d.user.Fs = afero.NewBasePathFs(d.user.Fs, basePath)
-
-		file, err = files.NewFileInfo(files.FileOptions{
-			Fs:      d.user.Fs,
-			Path:    filePath,
-			Modify:  d.user.Perm.Modify,
-			Expand:  true,
-			Checker: d,
-			Token:   link.Token,
-		})
-		if err != nil {
-			return errToStatus(err), err
-		}
-
 		d.raw = file
 		return fn(w, r, d)
 	}
 }
 
-// ref to https://github.com/filebrowser/filebrowser/pull/727
-// `/api/public/dl/MEEuZK-v/file-name.txt` for old browsers to save file with correct name
 func ifPathWithName(r *http.Request) (id, filePath string) {
 	pathElements := strings.Split(r.URL.Path, "/")
-	// prevent maliciously constructed parameters like `/api/public/dl/XZzCDnK2_not_exists_hash_name`
-	// len(pathElements) will be 1, and golang will panic `runtime error: index out of range`
-
-	switch len(pathElements) {
-	case 1:
-		return r.URL.Path, "/"
-	default:
-		return pathElements[0], path.Join("/", path.Join(pathElements[1:]...))
+	id = pathElements[0]
+	allButFirst := path.Join(pathElements[1:]...)
+	if len(pathElements) == 1 {
+		allButFirst = "/"
 	}
+	return id, allButFirst
 }
 
 var publicShareHandler = withHashFile(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
 	file := d.raw.(*files.FileInfo)
-
+	file.Path = strings.TrimPrefix(file.Path, settings.Config.Server.Root)
 	if file.IsDir {
-		file.Listing.Sorting = files.Sorting{By: "name", Asc: false}
-		file.Listing.ApplySort()
 		return renderJSON(w, r, file)
 	}
 
 	return renderJSON(w, r, file)
 })
 
+var publicUserGetHandler = func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+	// Call the actual handler logic here (e.g., renderJSON, etc.)
+	// You may need to replace `fn` with the actual handler logic.
+	return renderJSON(w, r, users.PublicUser)
+}
+
 var publicDlHandler = withHashFile(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
 	file := d.raw.(*files.FileInfo)
 	if !file.IsDir {
@@ -138,7 +117,6 @@ func authenticateShareRequest(r *http.Request, l *share.Link) (int, error) {
 		}
 		return 0, err
 	}
-
 	return 0, nil
 }
 

backend/http/public_test.go

@@ -26,7 +26,7 @@ func TestPublicShareHandlerAuthentication(t *testing.T) {
 		expectedStatusCode int
 	}{
 		"Public share, no auth required": {
-			share:              &share.Link{Hash: "h", UserID: 1},
+			share:              &share.Link{Hash: "h"},
 			req:                newHTTPRequest(t),
 			expectedStatusCode: 200,
 		},
@@ -82,10 +82,11 @@ func TestPublicShareHandlerAuthentication(t *testing.T) {
 				if err := storage.Share.Save(tc.share); err != nil {
 					t.Fatalf("failed to save share: %v", err)
 				}
-				if err := storage.Users.Save(&users.User{Username: "username", Password: "pw"}); err != nil {
-					t.Fatalf("failed to save user: %v", err)
-				}
-				if err := storage.Settings.Save(&settings.Settings{Key: []byte("key")}); err != nil {
+				if err := storage.Settings.Save(&settings.Settings{
+					Auth: settings.Auth{
+						Key: []byte("key"),
+					},
+				}); err != nil {
 					t.Fatalf("failed to save settings: %v", err)
 				}
 
@@ -96,7 +97,6 @@ func TestPublicShareHandlerAuthentication(t *testing.T) {
 
 				recorder := httptest.NewRecorder()
 				handler := handle(handler, "", storage, &settings.Server{})
-
 				handler.ServeHTTP(recorder, tc.req)
 				result := recorder.Result()
 				defer result.Body.Close()

backend/http/raw.go

@@ -81,7 +81,7 @@ var rawHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data)
 		return http.StatusAccepted, nil
 	}
 
-	file, err := files.NewFileInfo(files.FileOptions{
+	file, err := files.FileInfoFaster(files.FileOptions{
 		Fs:         d.user.Fs,
 		Path:       r.URL.Path,
 		Modify:     d.user.Perm.Modify,
@@ -92,7 +92,6 @@ var rawHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data)
 	if err != nil {
 		return errToStatus(err), err
 	}
-
 	if files.IsNamedPipe(file.Mode) {
 		setContentDisposition(w, r, file)
 		return 0, nil
@@ -109,7 +108,6 @@ func addFile(ar archiver.Writer, d *data, path, commonPath string) error {
 	if !d.Check(path) {
 		return nil
 	}
-
 	info, err := d.user.Fs.Stat(path)
 	if err != nil {
 		return err

backend/http/resource.go

@@ -20,25 +20,22 @@ import (
 )
 
 var resourceGetHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	file, err := files.NewFileInfo(files.FileOptions{
+	file, err := files.FileInfoFaster(files.FileOptions{
 		Fs:         d.user.Fs,
 		Path:       r.URL.Path,
 		Modify:     d.user.Perm.Modify,
 		Expand:     true,
 		ReadHeader: d.server.TypeDetectionByHeader,
 		Checker:    d,
-		Content:    true,
+		Content:    r.URL.Query().Get("content") == "true",
 	})
 	if err != nil {
 		return errToStatus(err), err
 	}
-
 	if file.IsDir {
 		file.Listing.Sorting = d.user.Sorting
-		file.Listing.ApplySort()
 		return renderJSON(w, r, file)
 	}
-
 	if checksum := r.URL.Query().Get("checksum"); checksum != "" {
 		err := file.Checksum(checksum)
 		if err == errors.ErrInvalidOption {
@@ -46,9 +43,6 @@ var resourceGetHandler = withUser(func(w http.ResponseWriter, r *http.Request, d
 		} else if err != nil {
 			return http.StatusInternalServerError, err
 		}
-
-		// do not waste bandwidth if we just want the checksum
-		file.Content = ""
 	}
 
 	return renderJSON(w, r, file)
@@ -60,7 +54,7 @@ func resourceDeleteHandler(fileCache FileCache) handleFunc {
 			return http.StatusForbidden, nil
 		}
 
-		file, err := files.NewFileInfo(files.FileOptions{
+		file, err := files.FileInfoFaster(files.FileOptions{
 			Fs:         d.user.Fs,
 			Path:       r.URL.Path,
 			Modify:     d.user.Perm.Modify,
@@ -102,7 +96,7 @@ func resourcePostHandler(fileCache FileCache) handleFunc {
 			return errToStatus(err), err
 		}
 
-		file, err := files.NewFileInfo(files.FileOptions{
+		file, err := files.FileInfoFaster(files.FileOptions{
 			Fs:         d.user.Fs,
 			Path:       r.URL.Path,
 			Modify:     d.user.Perm.Modify,
@@ -173,7 +167,6 @@ var resourcePutHandler = withUser(func(w http.ResponseWriter, r *http.Request, d
 		w.Header().Set("ETag", etag)
 		return nil
 	}, "save", r.URL.Path, "", d.user)
-
 	return errToStatus(err), err
 })
 
@@ -278,6 +271,10 @@ func writeFile(fs afero.Fs, dst string, in io.Reader) (os.FileInfo, error) {
 		return nil, err
 	}
 
+	//files.RefreshFileInfo(files.FileOptions{
+	//	Fs: info,
+	//})
+
 	return info, nil
 }
 
@@ -308,7 +305,7 @@ func patchAction(ctx context.Context, action, src, dst string, d *data, fileCach
 		src = path.Clean("/" + src)
 		dst = path.Clean("/" + dst)
 
-		file, err := files.NewFileInfo(files.FileOptions{
+		file, err := files.FileInfoFaster(files.FileOptions{
 			Fs:         d.user.Fs,
 			Path:       src,
 			Modify:     d.user.Perm.Modify,
@@ -338,14 +335,13 @@ type DiskUsageResponse struct {
 }
 
 var diskUsage = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
-	file, err := files.NewFileInfo(files.FileOptions{
+	file, err := files.FileInfoFaster(files.FileOptions{
 		Fs:         d.user.Fs,
 		Path:       r.URL.Path,
 		Modify:     d.user.Perm.Modify,
 		Expand:     false,
 		ReadHeader: false,
 		Checker:    d,
-		Content:    false,
 	})
 	if err != nil {
 		return errToStatus(err), err

backend/http/search.go

@@ -2,18 +2,22 @@ package http
 
 import (
 	"net/http"
+	"strings"
 
-	"github.com/gtsteffaniak/filebrowser/search"
+	"github.com/gtsteffaniak/filebrowser/files"
+	"github.com/gtsteffaniak/filebrowser/settings"
 )
 
 var searchHandler = withUser(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
 	response := []map[string]interface{}{}
 	query := r.URL.Query().Get("query")
-
 	// Retrieve the User-Agent and X-Auth headers from the request
 	sessionId := r.Header.Get("SessionId")
-	indexInfo, fileTypes := search.SearchAllIndexes(query, r.URL.Path, sessionId)
-	for _, path := range indexInfo {
+	userScope := r.Header.Get("UserScope")
+	index := files.GetIndex(settings.Config.Server.Root)
+	combinedScope := strings.TrimPrefix(userScope+r.URL.Path, ".")
+	results, fileTypes := index.Search(query, combinedScope, sessionId)
+	for _, path := range results {
 		responseObj := map[string]interface{}{
 			"path": path,
 			"dir":  true,

backend/http/settings.go

@@ -14,19 +14,19 @@ type settingsData struct {
 	UserHomeBasePath string                `json:"userHomeBasePath"`
 	Defaults         settings.UserDefaults `json:"defaults"`
 	Rules            []rules.Rule          `json:"rules"`
-	Branding         settings.Branding     `json:"branding"`
+	Frontend         settings.Frontend     `json:"frontend"`
 	Shell            []string              `json:"shell"`
 	Commands         map[string][]string   `json:"commands"`
 }
 
 var settingsGetHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
 	data := &settingsData{
-		Signup:           d.settings.Signup,
-		CreateUserDir:    d.settings.CreateUserDir,
-		UserHomeBasePath: d.settings.UserHomeBasePath,
-		Defaults:         d.settings.Defaults,
+		Signup:           settings.Config.Auth.Signup,
+		CreateUserDir:    settings.Config.Server.CreateUserDir,
+		UserHomeBasePath: settings.Config.Server.UserHomeBasePath,
+		Defaults:         d.settings.UserDefaults,
 		Rules:            d.settings.Rules,
-		Branding:         d.settings.Branding,
+		Frontend:         d.settings.Frontend,
 		Shell:            d.settings.Shell,
 		Commands:         d.settings.Commands,
 	}
@@ -41,15 +41,13 @@ var settingsPutHandler = withAdmin(func(w http.ResponseWriter, r *http.Request,
 		return http.StatusBadRequest, err
 	}
 
-	d.settings.Signup = req.Signup
-	d.settings.CreateUserDir = req.CreateUserDir
-	d.settings.UserHomeBasePath = req.UserHomeBasePath
-	d.settings.Defaults = req.Defaults
+	d.settings.Server.CreateUserDir = req.CreateUserDir
+	d.settings.Server.UserHomeBasePath = req.UserHomeBasePath
+	d.settings.UserDefaults = req.Defaults
 	d.settings.Rules = req.Rules
-	d.settings.Branding = req.Branding
+	d.settings.Frontend = req.Frontend
 	d.settings.Shell = req.Shell
 	d.settings.Commands = req.Commands
-
 	err = d.store.Settings.Save(d.settings)
 	return errToStatus(err), err
 })

backend/http/share.go

@@ -22,7 +22,6 @@ func withPermShare(fn handleFunc) handleFunc {
 		if !d.user.Perm.Share {
 			return http.StatusForbidden, nil
 		}
-
 		return fn(w, r, d)
 	})
 }
@@ -51,7 +50,6 @@ var shareListHandler = withPermShare(func(w http.ResponseWriter, r *http.Request
 		}
 		return s[i].Expire < s[j].Expire
 	})
-
 	return renderJSON(w, r, s)
 })
 
@@ -77,10 +75,15 @@ var shareDeleteHandler = withPermShare(func(w http.ResponseWriter, r *http.Reque
 	}
 
 	err := d.store.Share.Delete(hash)
+	if err != nil {
+		return errToStatus(err), err
+	}
+
 	return errToStatus(err), err
 })
 
 var sharePostHandler = withPermShare(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
+
 	var s *share.Link
 	var body share.CreateBody
 	if r.Body != nil {
@@ -126,22 +129,22 @@ var sharePostHandler = withPermShare(func(w http.ResponseWriter, r *http.Request
 	if err != nil {
 		return status, err
 	}
-
+	stringHash := ""
 	var token string
 	if len(hash) > 0 {
-		tokenBuffer := make([]byte, 96) //nolint:gomnd
+		tokenBuffer := make([]byte, 24) //nolint:gomnd
 		if _, err := rand.Read(tokenBuffer); err != nil {
 			return http.StatusInternalServerError, err
 		}
 		token = base64.URLEncoding.EncodeToString(tokenBuffer)
+		stringHash = string(hash)
 	}
-
 	s = &share.Link{
-		Path:         r.URL.Path,
+		Path:         strings.TrimSuffix(r.URL.Path, "/"),
 		Hash:         str,
 		Expire:       expire,
 		UserID:       d.user.ID,
-		PasswordHash: string(hash),
+		PasswordHash: stringHash,
 		Token:        token,
 	}
 
@@ -153,6 +156,7 @@ var sharePostHandler = withPermShare(func(w http.ResponseWriter, r *http.Request
 })
 
 func getSharePasswordHash(body share.CreateBody) (data []byte, statuscode int, err error) {
+
 	if body.Password == "" {
 		return nil, 0, nil
 	}

backend/http/static.go

@@ -21,33 +21,33 @@ import (
 func handleWithStaticData(w http.ResponseWriter, _ *http.Request, d *data, fSys fs.FS, file, contentType string) (int, error) {
 	w.Header().Set("Content-Type", contentType)
 
-	auther, err := d.store.Auth.Get(d.settings.AuthMethod)
+	auther, err := d.store.Auth.Get(d.settings.Auth.Method)
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}
 
 	data := map[string]interface{}{
-		"Name":                  d.settings.Branding.Name,
-		"DisableExternal":       d.settings.Branding.DisableExternal,
-		"DisableUsedPercentage": d.settings.Branding.DisableUsedPercentage,
-		"Color":                 d.settings.Branding.Color,
+		"Name":                  d.settings.Frontend.Name,
+		"DisableExternal":       d.settings.Frontend.DisableExternal,
+		"DisableUsedPercentage": d.settings.Frontend.DisableUsedPercentage,
+		"darkMode":              settings.Config.UserDefaults.DarkMode,
+		"Color":                 d.settings.Frontend.Color,
 		"BaseURL":               d.server.BaseURL,
 		"Version":               version.Version,
 		"StaticURL":             path.Join(d.server.BaseURL, "/static"),
-		"Signup":                d.settings.Signup,
-		"NoAuth":                d.settings.AuthMethod == auth.MethodNoAuth,
-		"AuthMethod":            d.settings.AuthMethod,
+		"Signup":                settings.Config.Auth.Signup,
+		"NoAuth":                d.settings.Auth.Method == "noauth",
+		"AuthMethod":            d.settings.Auth.Method,
 		"LoginPage":             auther.LoginPage(),
 		"CSS":                   false,
 		"ReCaptcha":             false,
-		"Theme":                 d.settings.Branding.Theme,
 		"EnableThumbs":          d.server.EnableThumbnails,
 		"ResizePreview":         d.server.ResizePreview,
 		"EnableExec":            d.server.EnableExec,
 	}
 
-	if d.settings.Branding.Files != "" {
-		fPath := filepath.Join(d.settings.Branding.Files, "custom.css")
+	if d.settings.Frontend.Files != "" {
+		fPath := filepath.Join(d.settings.Frontend.Files, "custom.css")
 		_, err := os.Stat(fPath) //nolint:govet
 
 		if err != nil && !os.IsNotExist(err) {
@@ -59,14 +59,12 @@ func handleWithStaticData(w http.ResponseWriter, _ *http.Request, d *data, fSys
 		}
 	}
 
-	if d.settings.AuthMethod == auth.MethodJSONAuth {
-		raw, err := d.store.Auth.Get(d.settings.AuthMethod) //nolint:govet
+	if d.settings.Auth.Method == "password" {
+		raw, err := d.store.Auth.Get(d.settings.Auth.Method) //nolint:govet
 		if err != nil {
 			return http.StatusInternalServerError, err
 		}
-
 		auther := raw.(*auth.JSONAuth)
-
 		if auther.ReCaptcha != nil {
 			data["ReCaptcha"] = auther.ReCaptcha.Key != "" && auther.ReCaptcha.Secret != ""
 			data["ReCaptchaHost"] = auther.ReCaptcha.Host
@@ -104,7 +102,7 @@ func getStaticHandlers(store *storage.Storage, server *settings.Server, assetsFs
 		}
 
 		w.Header().Set("x-xss-protection", "1; mode=block")
-		return handleWithStaticData(w, r, d, assetsFs, "index.html", "text/html; charset=utf-8")
+		return handleWithStaticData(w, r, d, assetsFs, "public/index.html", "text/html; charset=utf-8")
 	}, "", store, server)
 
 	static = handle(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
@@ -115,15 +113,15 @@ func getStaticHandlers(store *storage.Storage, server *settings.Server, assetsFs
 		const maxAge = 86400 // 1 day
 		w.Header().Set("Cache-Control", fmt.Sprintf("public, max-age=%v", maxAge))
 
-		if d.settings.Branding.Files != "" {
+		if d.settings.Frontend.Files != "" {
 			if strings.HasPrefix(r.URL.Path, "img/") {
-				fPath := filepath.Join(d.settings.Branding.Files, r.URL.Path)
+				fPath := filepath.Join(d.settings.Frontend.Files, r.URL.Path)
 				if _, err := os.Stat(fPath); err == nil {
 					http.ServeFile(w, r, fPath)
 					return 0, nil
 				}
-			} else if r.URL.Path == "custom.css" && d.settings.Branding.Files != "" {
-				http.ServeFile(w, r, filepath.Join(d.settings.Branding.Files, "custom.css"))
+			} else if r.URL.Path == "custom.css" && d.settings.Frontend.Files != "" {
+				http.ServeFile(w, r, filepath.Join(d.settings.Frontend.Files, "custom.css"))
 				return 0, nil
 			}
 		}
@@ -139,7 +137,7 @@ func getStaticHandlers(store *storage.Storage, server *settings.Server, assetsFs
 		}
 
 		w.Header().Set("Content-Encoding", "gzip")
-		w.Header().Set("Content-Type", "application/javascript; charset=utf-8")
+		w.Header().Set("Content-Type", "application/javascript; charset=utf-8") // Set the correct MIME type for JavaScript files
 
 		if _, err := w.Write(fileContents); err != nil {
 			return http.StatusInternalServerError, err

backend/http/users.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"log"
 	"net/http"
+	"reflect"
 	"sort"
 	"strconv"
 
@@ -19,6 +20,11 @@ var (
 	NonModifiableFieldsForNonAdmin = []string{"Username", "Scope", "LockPassword", "Perm", "Commands", "Rules"}
 )
 
+// SortingSettings represents the sorting settings.
+type Sorting struct {
+	By  string `json:"by"`
+	Asc bool   `json:"asc"`
+}
 type modifyUserRequest struct {
 	modifyRequest
 	Data *users.User `json:"data"`
@@ -57,7 +63,6 @@ func withSelfOrAdmin(fn handleFunc) handleFunc {
 		if err != nil {
 			return http.StatusInternalServerError, err
 		}
-
 		if d.user.ID != id && !d.user.Perm.Admin {
 			return http.StatusForbidden, nil
 		}
@@ -124,11 +129,6 @@ var userPostHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *
 		return http.StatusBadRequest, errors.ErrEmptyPassword
 	}
 
-	req.Data.Password, err = users.HashPwd(req.Data.Password)
-	if err != nil {
-		return http.StatusInternalServerError, err
-	}
-
 	userHome, err := d.settings.MakeUserDir(req.Data.Username, req.Data.Scope, d.server.Root)
 	if err != nil {
 		log.Printf("create user: failed to mkdir user home dir: [%s]", userHome)
@@ -156,35 +156,28 @@ var userPutHandler = withSelfOrAdmin(func(w http.ResponseWriter, r *http.Request
 		return http.StatusBadRequest, nil
 	}
 
-	if len(req.Which) == 0 || (len(req.Which) == 1 && req.Which[0] == "all") {
-		if !d.user.Perm.Admin {
-			return http.StatusForbidden, nil
-		}
-
-		if req.Data.Password != "" {
-			req.Data.Password, err = users.HashPwd(req.Data.Password)
-		} else {
-			var suser *users.User
-			suser, err = d.store.Users.Get(d.server.Root, d.raw.(uint))
-			req.Data.Password = suser.Password
-		}
-
-		if err != nil {
-			return http.StatusInternalServerError, err
-		}
-
+	if len(req.Which) == 0 || req.Which[0] == "all" {
 		req.Which = []string{}
+		v := reflect.ValueOf(req.Data)
+		if v.Kind() == reflect.Ptr {
+			v = v.Elem()
+		}
+		t := v.Type()
+		for i := 0; i < t.NumField(); i++ {
+			field := t.Field(i)
+			if field.Name != "Password" && field.Name != "Fs" {
+				req.Which = append(req.Which, field.Name)
+			}
+		}
 	}
 
 	for k, v := range req.Which {
 		v = cases.Title(language.English, cases.NoLower).String(v)
 		req.Which[k] = v
-
 		if v == "Password" {
 			if !d.user.Perm.Admin && d.user.LockPassword {
 				return http.StatusForbidden, nil
 			}
-
 			req.Data.Password, err = users.HashPwd(req.Data.Password)
 			if err != nil {
 				return http.StatusInternalServerError, err
@@ -197,7 +190,6 @@ var userPutHandler = withSelfOrAdmin(func(w http.ResponseWriter, r *http.Request
 			}
 		}
 	}
-
 	err = d.store.Users.Update(req.Data, req.Which...)
 	if err != nil {
 		return http.StatusInternalServerError, err

backend/http/utils.go

@@ -13,7 +13,6 @@ import (
 
 func renderJSON(w http.ResponseWriter, _ *http.Request, data interface{}) (int, error) {
 	marsh, err := json.Marshal(data)
-
 	if err != nil {
 		return http.StatusInternalServerError, err
 	}

backend/main.go

@@ -5,5 +5,5 @@ import (
 )
 
 func main() {
-	cmd.Execute()
+	cmd.StartFilebrowser()
 }

backend/rules/rules.go

@@ -17,6 +17,7 @@ type Rule struct {
 	Allow  bool    `json:"allow"`
 	Path   string  `json:"path"`
 	Regexp *Regexp `json:"regexp"`
+	Id     string  `json:"id"`
 }
 
 // MatchHidden matches paths with a basename

backend/run_benchmark.sh

@@ -1,6 +1,5 @@
 #!/bin/sh
 ## TEST file used by docker testing containers
-touch render.yml
 checkExit() {
     if [ "$?" -ne 0 ];then
         exit 1
@@ -10,7 +9,7 @@ checkExit() {
 if command -v go &> /dev/null
 then
     printf "\n == Running benchmark == \n"
-    go test -bench=. -benchmem ./...
+    go test -bench=. -benchtime=10x -benchmem ./...
     checkExit
 else
     echo "ERROR: unable to perform tests"

backend/run_tests.sh

@@ -1,6 +1,5 @@
 #!/bin/sh
 ## TEST file used by docker testing containers
-touch render.yml
 checkExit() {
     if [ "$?" -ne 0 ];then
         exit 1

backend/runner/runner.go

@@ -101,18 +101,18 @@ func (r *Runner) exec(raw, evt, path, dst string, user *users.User) error {
 	cmd.Stderr = os.Stderr
 
 	if !blocking {
-		log.Printf("[INFO] Nonblocking Command: \"%s\"", strings.Join(command, " "))
+		log.Printf("Nonblocking Command: \"%s\"", strings.Join(command, " "))
 		defer func() {
 			go func() {
 				err := cmd.Wait()
 				if err != nil {
-					log.Printf("[INFO] Nonblocking Command \"%s\" failed: %s", strings.Join(command, " "), err)
+					log.Printf("Nonblocking Command \"%s\" failed: %s", strings.Join(command, " "), err)
 				}
 			}()
 		}()
 		return cmd.Start()
 	}
 
-	log.Printf("[INFO] Blocking Command: \"%s\"", strings.Join(command, " "))
+	log.Printf("Blocking Command: \"%s\"", strings.Join(command, " "))
 	return cmd.Run()
 }

backend/search/indexing.go

@@ -1,279 +0,0 @@
-package search
-
-import (
-	"log"
-	"math/rand"
-	"mime"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-)
-
-var (
-	sessionInProgress sync.Map // Track session with requests in progress
-	rootPath          string   = "/srv"
-	indexes           map[string][]string
-	mutex             sync.RWMutex
-	lastIndexed       time.Time
-)
-
-func InitializeIndex(intervalMinutes uint32) {
-	// Initialize the indexes map
-	indexes = make(map[string][]string)
-	indexes["dirs"] = []string{}
-	indexes["files"] = []string{}
-	var numFiles, numDirs int
-	log.Println("Indexing files...")
-	lastIndexedStart := time.Now()
-	// Call the function to index files and directories
-	totalNumFiles, totalNumDirs, err := indexFiles(rootPath, &numFiles, &numDirs)
-	if err != nil {
-		log.Fatal(err)
-	}
-	lastIndexed = lastIndexedStart
-	go indexingScheduler(intervalMinutes)
-	log.Println("Successfully indexed files.")
-	log.Println("Files found       :", totalNumFiles)
-	log.Println("Directories found :", totalNumDirs)
-}
-
-func indexingScheduler(intervalMinutes uint32) {
-	log.Printf("Indexing scheduler will run every %v minutes", intervalMinutes)
-	for {
-		time.Sleep(time.Duration(intervalMinutes) * time.Minute)
-		var numFiles, numDirs int
-		lastIndexedStart := time.Now()
-		totalNumFiles, totalNumDirs, err := indexFiles(rootPath, &numFiles, &numDirs)
-		if err != nil {
-			log.Fatal(err)
-		}
-		lastIndexed = lastIndexedStart
-		if totalNumFiles+totalNumDirs > 0 {
-			log.Println("re-indexing found changes and updated the index.")
-		}
-	}
-}
-
-// Define a function to recursively index files and directories
-func indexFiles(path string, numFiles *int, numDirs *int) (int, int, error) {
-	// Check if the current directory has been modified since last indexing
-	dir, err := os.Open(path)
-	if err != nil {
-		// directory must have been deleted, remove from index
-		delete(indexes, path)
-	}
-	defer dir.Close()
-	dirInfo, err := dir.Stat()
-	if err != nil {
-		return *numFiles, *numDirs, err
-	}
-	// Compare the last modified time of the directory with the last indexed time
-	if dirInfo.ModTime().Before(lastIndexed) {
-		return *numFiles, *numDirs, nil
-	}
-	// Read the directory contents
-	files, err := dir.Readdir(-1)
-	if err != nil {
-		return *numFiles, *numDirs, err
-	}
-	// Iterate over the files and directories
-	for _, file := range files {
-		if file.IsDir() {
-			*numDirs++
-			addToIndex(path, file.Name(), true)
-			indexFiles(path+"/"+file.Name(), numFiles, numDirs) // recursive
-		} else {
-			*numFiles++
-			addToIndex(path, file.Name(), false)
-		}
-	}
-	return *numFiles, *numDirs, nil
-}
-
-func addToIndex(path string, fileName string, isDir bool) {
-	mutex.Lock()
-	defer mutex.Unlock()
-	path = strings.TrimPrefix(path, rootPath+"/")
-	path = strings.TrimSuffix(path, "/")
-	adjustedPath := path + "/" + fileName
-	if path == rootPath {
-		adjustedPath = fileName
-	}
-	if isDir {
-		indexes["dirs"] = append(indexes["dirs"], adjustedPath)
-	} else {
-		indexes["files"] = append(indexes["files"], adjustedPath)
-	}
-}
-
-func SearchAllIndexes(search string, scope string, sourceSession string) ([]string, map[string]map[string]bool) {
-	runningHash := generateRandomHash(4)
-	sessionInProgress.Store(sourceSession, runningHash) // Store the value in the sync.Map
-
-	searchOptions := ParseSearch(search)
-	mutex.RLock()
-	defer mutex.RUnlock()
-	fileListTypes := make(map[string]map[string]bool)
-	var matching []string
-	maximum := 100
-
-	for _, searchTerm := range searchOptions.Terms {
-		if searchTerm == "" {
-			continue
-		}
-		// Iterate over the indexes
-		for _, i := range []string{"dirs", "files"} {
-			isdir := i == "dirs"
-			count := 0
-			for _, path := range indexes[i] {
-				value, found := sessionInProgress.Load(sourceSession)
-				if !found || value != runningHash {
-					return []string{}, map[string]map[string]bool{}
-				}
-				if count > maximum {
-					break
-				}
-				pathName := scopedPathNameFilter(path, scope)
-				if pathName == "" {
-					continue
-				}
-				matches, fileType := containsSearchTerm(path, searchTerm, *searchOptions, isdir)
-				if !matches {
-					continue
-				}
-				if isdir {
-					pathName = pathName + "/"
-				}
-				matching = append(matching, pathName)
-				fileListTypes[pathName] = fileType
-				count++
-			}
-		}
-	}
-	// Sort the strings based on the number of elements after splitting by "/"
-	sort.Slice(matching, func(i, j int) bool {
-		parts1 := strings.Split(matching[i], "/")
-		parts2 := strings.Split(matching[j], "/")
-		return len(parts1) < len(parts2)
-	})
-	return matching, fileListTypes
-}
-
-func scopedPathNameFilter(pathName string, scope string) string {
-	scope = strings.TrimPrefix(scope, "/")
-	if strings.HasPrefix(pathName, scope) {
-		pathName = strings.TrimPrefix(pathName, scope)
-	} else {
-		pathName = ""
-	}
-	return pathName
-}
-
-func containsSearchTerm(pathName string, searchTerm string, options SearchOptions, isDir bool) (bool, map[string]bool) {
-	conditions := options.Conditions
-	path := getLastPathComponent(pathName)
-	// Convert to lowercase once
-	lowerSearchTerm := searchTerm
-	if !conditions["exact"] {
-		path = strings.ToLower(path)
-		lowerSearchTerm = strings.ToLower(searchTerm)
-	}
-	if strings.Contains(path, lowerSearchTerm) {
-		// Reuse the fileTypes map and clear its values
-		fileTypes := map[string]bool{
-			"audio":   false,
-			"image":   false,
-			"video":   false,
-			"doc":     false,
-			"archive": false,
-			"dir":     false,
-		}
-		// Calculate fileSize only if needed
-		var fileSize int64
-		if conditions["larger"] || conditions["smaller"] {
-			fileSize = getFileSize(pathName)
-		}
-		matchesAllConditions := true
-		extension := filepath.Ext(path)
-		mimetype := mime.TypeByExtension(extension)
-		fileTypes["audio"] = strings.HasPrefix(mimetype, "audio")
-		fileTypes["image"] = strings.HasPrefix(mimetype, "image")
-		fileTypes["video"] = strings.HasPrefix(mimetype, "video")
-		fileTypes["doc"] = isDoc(extension)
-		fileTypes["archive"] = isArchive(extension)
-		fileTypes["dir"] = isDir
-		for t, v := range conditions {
-			if t == "exact" {
-				continue
-			}
-			var matchesCondition bool
-			switch t {
-			case "larger":
-				matchesCondition = fileSize > int64(options.LargerThan)*1000000
-			case "smaller":
-				matchesCondition = fileSize < int64(options.SmallerThan)*1000000
-			default:
-				matchesCondition = v == fileTypes[t]
-			}
-			if !matchesCondition {
-				matchesAllConditions = false
-			}
-		}
-		return matchesAllConditions, fileTypes
-	}
-	// Clear variables and return
-	return false, map[string]bool{}
-}
-
-func isDoc(extension string) bool {
-	for _, typefile := range documentTypes {
-		if extension == typefile {
-			return true
-		}
-	}
-	return false
-}
-
-func getFileSize(filepath string) int64 {
-	fileInfo, err := os.Stat(rootPath + "/" + filepath)
-	if err != nil {
-		return 0
-	}
-	return fileInfo.Size()
-}
-
-func isArchive(extension string) bool {
-	for _, typefile := range compressedFile {
-		if extension == typefile {
-			return true
-		}
-	}
-	return false
-}
-
-func getLastPathComponent(path string) string {
-	// Use filepath.Base to extract the last component of the path
-	return filepath.Base(path)
-}
-
-func generateRandomHash(length int) string {
-	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
-	rand.Seed(rand.Int63()) // Automatically seeded based on current time
-	result := make([]byte, length)
-	for i := range result {
-		result[i] = charset[rand.Intn(len(charset))]
-	}
-	return string(result)
-}
-
-func stringExistsInArray(target string, strings []string) bool {
-	for _, s := range strings {
-		if s == target {
-			return true
-		}
-	}
-	return false
-}

backend/search/search_test.go

@@ -1,171 +0,0 @@
-package search
-
-import (
-	"encoding/json"
-	"fmt"
-	"math/rand"
-	"reflect"
-	"testing"
-	"time"
-)
-
-// loop over test files and compare output
-func TestParseSearch(t *testing.T) {
-	value := ParseSearch("my test search")
-	want := &SearchOptions{
-		Conditions: map[string]bool{
-			"exact": false,
-		},
-		Terms: []string{"my test search"},
-	}
-	if !reflect.DeepEqual(value, want) {
-		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
-	}
-	value = ParseSearch("case:exact my|test|search")
-	want = &SearchOptions{
-		Conditions: map[string]bool{
-			"exact": true,
-		},
-		Terms: []string{"my", "test", "search"},
-	}
-	if !reflect.DeepEqual(value, want) {
-		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
-	}
-	value = ParseSearch("type:largerThan=100 type:smallerThan=1000 test")
-	want = &SearchOptions{
-		Conditions: map[string]bool{
-			"exact":  false,
-			"larger": true,
-		},
-		Terms:       []string{"test"},
-		LargerThan:  100,
-		SmallerThan: 1000,
-	}
-	if !reflect.DeepEqual(value, want) {
-		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
-	}
-	value = ParseSearch("type:audio thisfile")
-	want = &SearchOptions{
-		Conditions: map[string]bool{
-			"exact": false,
-			"audio": true,
-		},
-		Terms: []string{"thisfile"},
-	}
-	if !reflect.DeepEqual(value, want) {
-		t.Fatalf("\n got:  %+v\n want: %+v", value, want)
-	}
-}
-
-func BenchmarkSearchAllIndexes(b *testing.B) {
-	indexes = make(map[string][]string)
-
-	// Create mock data
-	createMockData(500, 3) // 1000 dirs, 3 files per dir
-
-	// Generate 100 random search terms
-	searchTerms := generateRandomSearchTerms(100)
-
-	b.ResetTimer()
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		// Execute the SearchAllIndexes function
-		for _, term := range searchTerms {
-			SearchAllIndexes(term, "/")
-		}
-	}
-	printBenchmarkResults(b)
-}
-
-func BenchmarkFillIndex(b *testing.B) {
-	indexes = make(map[string][]string)
-	b.ResetTimer()
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		createMockData(10000, 10) // 1000 dirs, 3 files per dir
-	}
-	printBenchmarkResults(b)
-}
-
-func createMockData(numDirs, numFilesPerDir int) {
-	for i := 0; i < numDirs; i++ {
-		dirName := "srv/" + getRandomTerm()
-		addToIndex("/", dirName, true)
-		for j := 0; j < numFilesPerDir; j++ {
-			fileName := "file-" + getRandomTerm() + getRandomExtension()
-			addToIndex("/"+dirName, fileName, false)
-		}
-	}
-}
-
-func getRandomTerm() string {
-	wordbank := []string{
-		"hi", "test", "other", "name",
-		"cool", "things", "more", "items",
-	}
-	rand.Seed(time.Now().UnixNano())
-	index := rand.Intn(len(wordbank))
-	return wordbank[index]
-}
-
-func getRandomExtension() string {
-	wordbank := []string{
-		".txt", ".mp3", ".mov", ".doc",
-		".mp4", ".bak", ".zip", ".jpg",
-	}
-	rand.Seed(time.Now().UnixNano())
-	index := rand.Intn(len(wordbank))
-	return wordbank[index]
-}
-
-func generateRandomSearchTerms(numTerms int) []string {
-	// Generate random search terms
-	searchTerms := make([]string, numTerms)
-	for i := 0; i < numTerms; i++ {
-		searchTerms[i] = getRandomTerm()
-	}
-	return searchTerms
-}
-
-// JSONBytesEqual compares the JSON in two byte slices.
-func JSONBytesEqual(a, b []byte) (bool, error) {
-	var j, j2 interface{}
-	if err := json.Unmarshal(a, &j); err != nil {
-		return false, err
-	}
-	if err := json.Unmarshal(b, &j2); err != nil {
-		return false, err
-	}
-	return reflect.DeepEqual(j2, j), nil
-}
-
-func passedFunc(t *testing.T) {
-	t.Logf("%s passed!", t.Name())
-}
-
-func formatDuration(duration time.Duration) string {
-	if duration >= time.Second {
-		return fmt.Sprintf("%.2f seconds", duration.Seconds())
-	} else if duration >= time.Millisecond {
-		return fmt.Sprintf("%.2f ms", float64(duration.Milliseconds()))
-	}
-	return fmt.Sprintf("%.2f ns", float64(duration.Nanoseconds()))
-}
-
-func formatMemory(bytes int64) string {
-	sizes := []string{"B", "KB", "MB", "GB", "TB"}
-	i := 0
-	for bytes >= 1024 && i < len(sizes)-1 {
-		bytes /= 1024
-		i++
-	}
-	return fmt.Sprintf("%d %s", bytes, sizes[i])
-}
-
-// Output the benchmark results with human-readable units
-func printBenchmarkResults(b *testing.B) {
-	averageTimePerIteration := b.Elapsed() / time.Duration(b.N)
-	fmt.Printf("\nIterations            : %d\n", b.N)
-	fmt.Printf("Total time            : %s\n", formatDuration(b.Elapsed()))
-	fmt.Printf("Avg time per op       : %s\n", formatDuration(averageTimePerIteration))
-}

backend/settings/config.go

@@ -0,0 +1,108 @@
+package settings
+
+import (
+	"log"
+	"os"
+	"strings"
+
+	"github.com/goccy/go-yaml"
+	"github.com/gtsteffaniak/filebrowser/users"
+)
+
+var Config Settings
+
+func Initialize(configFile string) {
+	yamlData := loadConfigFile(configFile)
+	Config = setDefaults()
+	err := yaml.Unmarshal(yamlData, &Config)
+	if err != nil {
+		log.Fatalf("Error unmarshaling YAML data: %v", err)
+	}
+	Config.UserDefaults.Perm = Config.UserDefaults.Permissions
+	Config.Server.Root = strings.TrimSuffix(Config.Server.Root, "/")
+}
+
+func loadConfigFile(configFile string) []byte {
+	// Open and read the YAML file
+	yamlFile, err := os.Open(configFile)
+	if err != nil {
+		log.Printf("ERROR: opening config file\n %v\n WARNING: Using default config only\n If this was a mistake, please make sure the file exists and is accessible by the filebrowser binary.\n\n", err)
+		Config = setDefaults()
+		return []byte{}
+	}
+	defer yamlFile.Close()
+
+	stat, err := yamlFile.Stat()
+	if err != nil {
+		log.Fatalf("Error getting file information: %s", err.Error())
+	}
+
+	yamlData := make([]byte, stat.Size())
+	_, err = yamlFile.Read(yamlData)
+	if err != nil {
+		log.Fatalf("Error reading YAML data: %v", err)
+	}
+	return yamlData
+}
+
+func setDefaults() Settings {
+	return Settings{
+		Server: Server{
+			EnableThumbnails:   true,
+			ResizePreview:      false,
+			EnableExec:         false,
+			IndexingInterval:   5,
+			Port:               80,
+			NumImageProcessors: 4,
+			BaseURL:            "",
+			Database:           "database.db",
+			Log:                "stdout",
+			Root:               "/srv",
+			Indexing:           true,
+		},
+		Auth: Auth{
+			TokenExpirationTime: "2h",
+			AdminUsername:       "admin",
+			AdminPassword:       "admin",
+			Method:              "password",
+			Signup:              false,
+			Recaptcha: Recaptcha{
+				Host: "",
+			},
+		},
+		UserDefaults: UserDefaults{
+			StickySidebar:   true,
+			Scope:           ".",
+			LockPassword:    false,
+			HideDotfiles:    true,
+			DarkMode:        false,
+			DisableSettings: false,
+			Locale:          "en",
+			Permissions: users.Permissions{
+				Create:   false,
+				Rename:   false,
+				Modify:   false,
+				Delete:   false,
+				Share:    false,
+				Download: false,
+				Admin:    false,
+			},
+		},
+	}
+}
+
+// Apply applies the default options to a user.
+func (d *UserDefaults) Apply(u *users.User) {
+	u.StickySidebar = d.StickySidebar
+	u.DisableSettings = d.DisableSettings
+	u.DarkMode = d.DarkMode
+	u.Scope = d.Scope
+	u.Locale = d.Locale
+	u.ViewMode = d.ViewMode
+	u.SingleClick = d.SingleClick
+	u.Perm = d.Perm
+	u.Sorting = d.Sorting
+	u.Commands = d.Commands
+	u.HideDotfiles = d.HideDotfiles
+	u.DateFormat = d.DateFormat
+}

backend/settings/config_test.go

@@ -0,0 +1,59 @@
+package settings
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestInitialize(t *testing.T) {
+	type args struct {
+		configFile string
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			Initialize(tt.args.configFile)
+		})
+	}
+}
+
+func Test_loadConfigFile(t *testing.T) {
+	type args struct {
+		configFile string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []byte
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := loadConfigFile(tt.args.configFile); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("loadConfigFile() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_setDefaults(t *testing.T) {
+	tests := []struct {
+		name string
+		want Settings
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := setDefaults(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("setDefaults() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

backend/settings/dir.go

@@ -21,13 +21,13 @@ var (
 // MakeUserDir makes the user directory according to settings.
 func (s *Settings) MakeUserDir(username, userScope, serverRoot string) (string, error) {
 	userScope = strings.TrimSpace(userScope)
-	if userScope == "" && s.CreateUserDir {
+	if userScope == "" && s.Server.CreateUserDir {
 		username = cleanUsername(username)
 		if username == "" || username == "-" || username == "." {
 			log.Printf("create user: invalid user for home dir creation: [%s]", username)
 			return "", errors.New("invalid user for home dir creation")
 		}
-		userScope = path.Join(s.UserHomeBasePath, username)
+		userScope = path.Join(s.Server.UserHomeBasePath, username)
 	}
 
 	userScope = path.Join("/", userScope)

backend/settings/dir_test.go

@@ -0,0 +1,81 @@
+package settings
+
+import (
+	"testing"
+
+	"github.com/gtsteffaniak/filebrowser/rules"
+)
+
+func TestSettings_MakeUserDir(t *testing.T) {
+	type fields struct {
+		Signup           bool
+		CreateUserDir    bool
+		UserHomeBasePath string
+		Commands         map[string][]string
+		Shell            []string
+		AdminUsername    string
+		AdminPassword    string
+		Rules            []rules.Rule
+		Server           Server
+		Auth             Auth
+		Frontend         Frontend
+		Users            []UserDefaults
+		UserDefaults     UserDefaults
+	}
+	type args struct {
+		username   string
+		userScope  string
+		serverRoot string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    string
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &Settings{
+				Commands:     tt.fields.Commands,
+				Shell:        tt.fields.Shell,
+				Rules:        tt.fields.Rules,
+				Server:       tt.fields.Server,
+				Auth:         tt.fields.Auth,
+				Frontend:     tt.fields.Frontend,
+				Users:        tt.fields.Users,
+				UserDefaults: tt.fields.UserDefaults,
+			}
+			got, err := s.MakeUserDir(tt.args.username, tt.args.userScope, tt.args.serverRoot)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Settings.MakeUserDir() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("Settings.MakeUserDir() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_cleanUsername(t *testing.T) {
+	type args struct {
+		s string
+	}
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := cleanUsername(tt.args.s); got != tt.want {
+				t.Errorf("cleanUsername() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

backend/settings/settings.go

@@ -35,3 +35,7 @@ func GenerateKey() ([]byte, error) {
 
 	return b, nil
 }
+
+func GetSettingsConfig(nameType string, Value string) string {
+	return nameType + Value
+}

backend/settings/settings_test.go

@@ -0,0 +1,54 @@
+package settings
+
+import (
+	"log"
+	"testing"
+
+	"github.com/goccy/go-yaml"
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestConfigLoadChanged(t *testing.T) {
+	yamlData := loadConfigFile("./testingConfig.yaml")
+	// Marshal the YAML data to a more human-readable format
+	newConfig := setDefaults()
+	Config := setDefaults()
+
+	err := yaml.Unmarshal(yamlData, &newConfig)
+	if err != nil {
+		log.Fatalf("Error unmarshaling YAML data: %v", err)
+	}
+	// Use go-cmp to compare the two structs
+	if diff := cmp.Diff(newConfig, Config); diff == "" {
+		t.Errorf("No change when there should have been (-want +got):\n%s", diff)
+	}
+}
+
+func TestConfigLoadSpecificValues(t *testing.T) {
+	yamlData := loadConfigFile("./testingConfig.yaml")
+	// Marshal the YAML data to a more human-readable format
+	newConfig := setDefaults()
+	Config := setDefaults()
+
+	err := yaml.Unmarshal(yamlData, &newConfig)
+	if err != nil {
+		log.Fatalf("Error unmarshaling YAML data: %v", err)
+	}
+	testCases := []struct {
+		fieldName string
+		globalVal interface{}
+		newVal    interface{}
+	}{
+		{"Auth.Method", Config.Auth.Method, newConfig.Auth.Method},
+		{"Auth.Method", Config.Auth.Method, newConfig.Auth.Method},
+		{"Frontend.disableExternal", Config.Frontend.DisableExternal, newConfig.Frontend.DisableExternal},
+		{"UserDefaults.HideDotfiles", Config.UserDefaults.HideDotfiles, newConfig.UserDefaults.HideDotfiles},
+		{"Server.Database", Config.Server.Database, newConfig.Server.Database},
+	}
+
+	for _, tc := range testCases {
+		if tc.globalVal == tc.newVal {
+			t.Errorf("Differences should have been found:\n\tConfig.%s: %v \n\tSetConfig: %v \n", tc.fieldName, tc.globalVal, tc.newVal)
+		}
+	}
+}

backend/settings/storage.go

@@ -3,7 +3,6 @@ package settings
 import (
 	"github.com/gtsteffaniak/filebrowser/errors"
 	"github.com/gtsteffaniak/filebrowser/rules"
-	"github.com/gtsteffaniak/filebrowser/users"
 )
 
 // StorageBackend is a settings storage backend.
@@ -30,8 +29,8 @@ func (s *Storage) Get() (*Settings, error) {
 	if err != nil {
 		return nil, err
 	}
-	if set.UserHomeBasePath == "" {
-		set.UserHomeBasePath = DefaultUsersHomeBasePath
+	if set.Server.UserHomeBasePath == "" {
+		set.Server.UserHomeBasePath = DefaultUsersHomeBasePath
 	}
 	return set, nil
 }
@@ -46,20 +45,20 @@ var defaultEvents = []string{
 
 // Save saves the settings for the current instance.
 func (s *Storage) Save(set *Settings) error {
-	if len(set.Key) == 0 {
+	if len(set.Auth.Key) == 0 {
 		return errors.ErrEmptyKey
 	}
 
-	if set.Defaults.Locale == "" {
-		set.Defaults.Locale = "en"
+	if set.UserDefaults.Locale == "" {
+		set.UserDefaults.Locale = "en"
 	}
 
-	if set.Defaults.Commands == nil {
-		set.Defaults.Commands = []string{}
+	if set.UserDefaults.Commands == nil {
+		set.UserDefaults.Commands = []string{}
 	}
 
-	if set.Defaults.ViewMode == "" {
-		set.Defaults.ViewMode = users.MosaicViewMode
+	if set.UserDefaults.ViewMode == "" {
+		set.UserDefaults.ViewMode = "normal"
 	}
 
 	if set.Rules == nil {

backend/settings/structs.go

@@ -1,49 +1,43 @@
 package settings
 
 import (
-	"github.com/gtsteffaniak/filebrowser/files"
 	"github.com/gtsteffaniak/filebrowser/rules"
 	"github.com/gtsteffaniak/filebrowser/users"
 )
 
-// Apply applies the default options to a user.
-func (d *UserDefaults) Apply(u *users.User) {
-	u.Scope = d.Scope
-	u.Locale = d.Locale
-	u.ViewMode = d.ViewMode
-	u.SingleClick = d.SingleClick
-	u.Perm = d.Perm
-	u.Sorting = d.Sorting
-	u.Commands = d.Commands
-	u.HideDotfiles = d.HideDotfiles
-	u.DateFormat = d.DateFormat
+type Settings struct {
+	Commands     map[string][]string `json:"commands"`
+	Shell        []string            `json:"shell"`
+	Rules        []rules.Rule        `json:"rules"`
+	Server       Server              `json:"server"`
+	Auth         Auth                `json:"auth"`
+	Frontend     Frontend            `json:"frontend"`
+	Users        []UserDefaults      `json:"users,omitempty"`
+	UserDefaults UserDefaults        `json:"userDefaults"`
 }
 
-type Settings struct {
-	Key              []byte              `json:"key"`
-	Signup           bool                `json:"signup"`
-	CreateUserDir    bool                `json:"createUserDir"`
-	UserHomeBasePath string              `json:"userHomeBasePath"`
-	Defaults         UserDefaults        `json:"defaults"`
-	Commands         map[string][]string `json:"commands"`
-	Shell            []string            `json:"shell"`
-	Rules            []rules.Rule        `json:"rules"`
-	Server           Server              `json:"server"`
-	AuthMethod       string              `json:"authMethod"`
-	Auth             struct {
-		Header  string `json:"header"`
-		Method  string `json:"method"`
-		Command string `json:"command"`
-		Signup  bool   `json:"signup"`
-		Shell   string `json:"shell"`
-	} `json:"auth"`
+type Auth struct {
+	TokenExpirationTime string    `json:"tokenExpirationTime"`
+	Recaptcha           Recaptcha `json:"recaptcha"`
+	Header              string    `json:"header"`
+	Method              string    `json:"method"`
+	Command             string    `json:"command"`
+	Signup              bool      `json:"signup"`
+	Shell               string    `json:"shell"`
+	AdminUsername       string    `json:"adminUsername"`
+	AdminPassword       string    `json:"adminPassword"`
+	Key                 []byte    `json:"key"`
+}
 
-	Branding Branding `json:"branding"`
-
-	UserDefaults UserDefaults `json:"userDefaults"`
+type Recaptcha struct {
+	Host   string `json:"host"`
+	Key    string `json:"key"`
+	Secret string `json:"secret"`
 }
 
 type Server struct {
+	IndexingInterval      uint32 `json:"indexingInterval"`
+	NumImageProcessors    int    `json:"numImageProcessors"`
 	Socket                string `json:"socket"`
 	TLSKey                string `json:"tlsKey"`
 	TLSCert               string `json:"tlsCert"`
@@ -52,76 +46,44 @@ type Server struct {
 	EnableExec            bool   `json:"enableExec"`
 	TypeDetectionByHeader bool   `json:"typeDetectionByHeader"`
 	AuthHook              string `json:"authHook"`
-	Port                  string `json:"port"`
+	Port                  int    `json:"port"`
 	BaseURL               string `json:"baseURL"`
 	Address               string `json:"address"`
 	Log                   string `json:"log"`
 	Database              string `json:"database"`
 	Root                  string `json:"root"`
-	EnablePreviewResize   bool   `json:"disable-preview-resize"`
+	UserHomeBasePath      string `json:"userHomeBasePath"`
+	CreateUserDir         bool   `json:"createUserDir"`
+	Indexing              bool   `json:"indexing"`
 }
 
-type Branding struct {
+type Frontend struct {
 	Name                  string `json:"name"`
 	DisableExternal       bool   `json:"disableExternal"`
 	DisableUsedPercentage bool   `json:"disableUsedPercentage"`
 	Files                 string `json:"files"`
-	Theme                 string `json:"theme"`
 	Color                 string `json:"color"`
 }
 
 // UserDefaults is a type that holds the default values
 // for some fields on User.
 type UserDefaults struct {
-	Scope        string            `json:"scope"`
-	Locale       string            `json:"locale"`
-	ViewMode     users.ViewMode    `json:"viewMode"`
-	SingleClick  bool              `json:"singleClick"`
-	Sorting      files.Sorting     `json:"sorting"`
+	StickySidebar   bool         `json:"stickySidebar"`
+	DarkMode        bool         `json:"darkMode"`
+	LockPassword    bool         `json:"lockPassword"`
+	DisableSettings bool         `json:"disableSettings,omitempty"`
+	Scope           string       `json:"scope"`
+	Locale          string       `json:"locale"`
+	ViewMode        string       `json:"viewMode"`
+	SingleClick     bool         `json:"singleClick"`
+	Rules           []rules.Rule `json:"rules"`
+	Sorting         struct {
+		By  string `json:"by"`
+		Asc bool   `json:"asc"`
+	} `json:"sorting"`
 	Perm         users.Permissions `json:"perm"`
-	Commands     []string          `json:"commands"`
+	Permissions  users.Permissions `json:"permissions"`
+	Commands     []string          `json:"commands,omitempty"`
 	HideDotfiles bool              `json:"hideDotfiles"`
 	DateFormat   bool              `json:"dateFormat"`
 }
-
-//{
-//	"server":{
-//	   "port":8080,
-//	   "baseURL":"",
-//	   "address":"",
-//	   "log":"stdout",
-//	   "database":"./database.db",
-//	   "root":"/srv",
-//	   "disable-thumbnails":false,
-//	   "disable-preview-resize":false,
-//	   "disable-exec":false,
-//	   "disable-type-detection-by-header":false
-//	},
-//	"auth":{
-//	   "header":"",
-//	   "method":"",
-//	   "command":"",
-//	   "signup":false,
-//	   "shell":""
-//	},
-//	"branding":{
-//	   "name":"",
-//	   "color":"",
-//	   "files":"",
-//	   "disableExternal":"",
-//	   "disableUsedPercentage":""
-//	},
-//	"permissions":{
-//	   "Admin":false,
-//	   "Execute":true,
-//	   "Create":true,
-//	   "Rename":true,
-//	   "Modify":true,
-//	   "Delete":true,
-//	   "Share":true,
-//	   "Download":true
-//	},
-//	"commands":{},
-//	"shell":{},
-//	"rules":{}
-// }

backend/settings/testingConfig.yaml

@@ -0,0 +1,52 @@
+server:
+  indexingInterval: 5
+  numImageProcessors: 4
+  socket: ""
+  tlsKey: ""
+  tlsCert: ""
+  enableThumbnails: false
+  resizePreview: true
+  typeDetectionByHeader: true
+  port: 80
+  baseURL: "/"
+  address: ""
+  log: "stdout"
+  database: "mydb.db"
+  root: "/srv"
+auth:
+  recaptcha:
+    host: ""
+    key: ""
+    secret: ""
+  header: ""
+  method: json
+  command: ""
+  signup: false
+  shell: ""
+frontend:
+  name: ""
+  disableExternal: true
+  disableUsedPercentage: true
+  files: ""
+  color: ""
+userDefaults:
+  scope: ""
+  locale: ""
+  viewMode: ""
+  darkMode: true
+  disableSettings: false
+  singleClick: true
+  sorting:
+    by: ""
+    asc: true
+  permissions:
+    admin: true
+    execute: true
+    create: true
+    rename: true
+    modify: true
+    delete: true
+    share: true
+    download: true
+  hideDotfiles: false
+  dateFormat: false

backend/storage/bolt/auth.go

@@ -2,7 +2,6 @@ package bolt
 
 import (
 	"github.com/asdine/storm/v3"
-
 	"github.com/gtsteffaniak/filebrowser/auth"
 	"github.com/gtsteffaniak/filebrowser/errors"
 )
@@ -13,20 +12,18 @@ type authBackend struct {
 
 func (s authBackend) Get(t string) (auth.Auther, error) {
 	var auther auth.Auther
-
 	switch t {
-	case auth.MethodJSONAuth:
+	case "password":
 		auther = &auth.JSONAuth{}
-	case auth.MethodProxyAuth:
+	case "proxy":
 		auther = &auth.ProxyAuth{}
-	case auth.MethodHookAuth:
+	case "hook":
 		auther = &auth.HookAuth{}
-	case auth.MethodNoAuth:
+	case "noauth":
 		auther = &auth.NoAuth{}
 	default:
 		return nil, errors.ErrInvalidAuthMethod
 	}
-
 	return auther, get(s.db, "auther", auther)
 }
 

backend/storage/bolt/config.go

@@ -2,7 +2,6 @@ package bolt
 
 import (
 	"github.com/asdine/storm/v3"
-
 	"github.com/gtsteffaniak/filebrowser/settings"
 )
 
@@ -20,7 +19,10 @@ func (s settingsBackend) Save(set *settings.Settings) error {
 }
 
 func (s settingsBackend) GetServer() (*settings.Server, error) {
-	server := &settings.Server{}
+	server := &settings.Server{
+		Port:               80,
+		NumImageProcessors: 1,
+	}
 	return server, get(s.db, "server", server)
 }
 

backend/storage/bolt/importer/conf.go

@@ -1,187 +0,0 @@
-package importer
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/asdine/storm/v3"
-	"github.com/pelletier/go-toml/v2"
-	"gopkg.in/yaml.v2"
-
-	"github.com/gtsteffaniak/filebrowser/auth"
-	"github.com/gtsteffaniak/filebrowser/settings"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-)
-
-type oldDefs struct {
-	Commands      []string `json:"commands" yaml:"commands" toml:"commands"`
-	Scope         string   `json:"scope" yaml:"scope" toml:"scope"`
-	ViewMode      string   `json:"viewMode" yaml:"viewMode" toml:"viewMode"`
-	Locale        string   `json:"locale" yaml:"locale" toml:"locale"`
-	AllowCommands bool     `json:"allowCommands" yaml:"allowCommands" toml:"allowCommands"`
-	AllowEdit     bool     `json:"allowEdit" yaml:"allowEdit" toml:"allowEdit"`
-	AllowNew      bool     `json:"allowNew" yaml:"allowNew" toml:"allowNew"`
-}
-
-type oldAuth struct {
-	Method  string `json:"method" yaml:"method" toml:"method"` // default none proxy
-	Header  string `json:"header" yaml:"header" toml:"header"`
-	Command string `json:"command" yaml:"command" toml:"command"`
-}
-
-type oldConf struct {
-	Port      string  `json:"port" yaml:"port" toml:"port"`
-	BaseURL   string  `json:"baseURL" yaml:"baseURL" toml:"baseURL"`
-	Log       string  `json:"log" yaml:"log" toml:"log"`
-	Address   string  `json:"address" yaml:"address" toml:"address"`
-	Defaults  oldDefs `json:"defaults" yaml:"defaults" toml:"defaults"`
-	ReCaptcha struct {
-		Key    string `json:"key" yaml:"key" toml:"key"`
-		Secret string `json:"secret" yaml:"secret" toml:"secret"`
-		Host   string `json:"host" yaml:"host" toml:"host"`
-	} `json:"recaptcha" yaml:"recaptcha" toml:"recaptcha"`
-	Auth oldAuth `json:"auth" yaml:"auth" toml:"auth"`
-}
-
-var defaults = &oldConf{
-	Port: "0",
-	Log:  "stdout",
-	Defaults: oldDefs{
-		Commands:      []string{"git", "svn", "hg"},
-		ViewMode:      string(users.MosaicViewMode),
-		AllowCommands: true,
-		AllowEdit:     true,
-		AllowNew:      true,
-		Locale:        "en",
-	},
-	Auth: oldAuth{
-		Method: "default",
-	},
-}
-
-func readConf(path string) (*oldConf, error) {
-	cfg := &oldConf{}
-	if path != "" {
-		ext := filepath.Ext(path)
-
-		fd, err := os.Open(path)
-		if err != nil {
-			return nil, err
-		}
-		defer fd.Close()
-
-		switch ext {
-		case ".json":
-			err = json.NewDecoder(fd).Decode(cfg)
-		case ".toml":
-			err = toml.NewDecoder(fd).Decode(cfg)
-		case ".yaml", ".yml":
-			err = yaml.NewDecoder(fd).Decode(cfg)
-		default:
-			return nil, errors.New("unsupported config extension " + ext)
-		}
-
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		cfg = defaults
-		path, err := filepath.Abs(".")
-		if err != nil {
-			return nil, err
-		}
-		cfg.Defaults.Scope = path
-	}
-	return cfg, nil
-}
-
-func importConf(db *storm.DB, path string, sto *storage.Storage) error {
-	cfg, err := readConf(path)
-	if err != nil {
-		return err
-	}
-
-	commands := map[string][]string{}
-	err = db.Get("config", "commands", &commands)
-	if err != nil {
-		return err
-	}
-
-	key := []byte{}
-	err = db.Get("config", "key", &key)
-	if err != nil {
-		return err
-	}
-
-	s := &settings.Settings{
-		Key:    key,
-		Signup: false,
-		Defaults: settings.UserDefaults{
-			Scope:    cfg.Defaults.Scope,
-			Commands: cfg.Defaults.Commands,
-			ViewMode: users.ViewMode(cfg.Defaults.ViewMode),
-			Locale:   cfg.Defaults.Locale,
-			Perm: users.Permissions{
-				Admin:    false,
-				Execute:  cfg.Defaults.AllowCommands,
-				Create:   cfg.Defaults.AllowNew,
-				Rename:   cfg.Defaults.AllowEdit,
-				Modify:   cfg.Defaults.AllowEdit,
-				Delete:   cfg.Defaults.AllowEdit,
-				Share:    true,
-				Download: true,
-			},
-		},
-	}
-
-	server := &settings.Server{
-		BaseURL: cfg.BaseURL,
-		Port:    cfg.Port,
-		Address: cfg.Address,
-		Log:     cfg.Log,
-	}
-
-	var auther auth.Auther
-	switch cfg.Auth.Method {
-	case "proxy":
-		auther = &auth.ProxyAuth{Header: cfg.Auth.Header}
-		s.AuthMethod = string(auth.MethodProxyAuth)
-	case "hook":
-		auther = &auth.HookAuth{Command: cfg.Auth.Command}
-		s.AuthMethod = string(auth.MethodHookAuth)
-	case "none":
-		auther = &auth.NoAuth{}
-		s.AuthMethod = string(auth.MethodNoAuth)
-	default:
-		auther = &auth.JSONAuth{
-			ReCaptcha: &auth.ReCaptcha{
-				Host:   cfg.ReCaptcha.Host,
-				Key:    cfg.ReCaptcha.Key,
-				Secret: cfg.ReCaptcha.Secret,
-			},
-		}
-		s.AuthMethod = string(auth.MethodJSONAuth)
-	}
-
-	err = sto.Auth.Save(auther)
-	if err != nil {
-		return err
-	}
-
-	err = sto.Settings.Save(s)
-	if err != nil {
-		return err
-	}
-
-	err = sto.Settings.SaveServer(server)
-	if err != nil {
-		return err
-	}
-
-	fmt.Println("Configuration successfully imported.")
-	return nil
-}

backend/storage/bolt/importer/importer.go

@@ -1,39 +0,0 @@
-package importer
-
-import (
-	"github.com/asdine/storm/v3"
-
-	"github.com/gtsteffaniak/filebrowser/storage/bolt"
-)
-
-// Import imports an old configuration to a newer database.
-func Import(oldDBPath, oldConf, newDBPath string) error {
-	oldDB, err := storm.Open(oldDBPath)
-	if err != nil {
-		return err
-	}
-	defer oldDB.Close()
-
-	newDB, err := storm.Open(newDBPath)
-	if err != nil {
-		return err
-	}
-	defer newDB.Close()
-
-	sto, err := bolt.NewStorage(newDB)
-	if err != nil {
-		return err
-	}
-
-	err = importUsers(oldDB, sto)
-	if err != nil {
-		return err
-	}
-
-	err = importConf(oldDB, oldConf, sto)
-	if err != nil {
-		return err
-	}
-
-	return err
-}

backend/storage/bolt/importer/users.go

@@ -1,114 +0,0 @@
-package importer
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/asdine/storm/v3"
-	bolt "go.etcd.io/bbolt"
-
-	"github.com/gtsteffaniak/filebrowser/rules"
-	"github.com/gtsteffaniak/filebrowser/storage"
-	"github.com/gtsteffaniak/filebrowser/users"
-)
-
-type oldUser struct {
-	ID            int           `storm:"id,increment"`
-	Admin         bool          `json:"admin"`
-	AllowCommands bool          `json:"allowCommands"` // Execute commands
-	AllowEdit     bool          `json:"allowEdit"`     // Edit/rename files
-	AllowNew      bool          `json:"allowNew"`      // Create files and folders
-	AllowPublish  bool          `json:"allowPublish"`  // Publish content (to use with static gen)
-	LockPassword  bool          `json:"lockPassword"`
-	Commands      []string      `json:"commands"`
-	Locale        string        `json:"locale"`
-	Password      string        `json:"password"`
-	Rules         []*rules.Rule `json:"rules"`
-	Scope         string        `json:"filesystem"`
-	Username      string        `json:"username" storm:"index,unique"`
-	ViewMode      string        `json:"viewMode"`
-}
-
-func readOldUsers(db *storm.DB) ([]*oldUser, error) {
-	var oldUsers []*oldUser
-	err := db.Bolt.View(func(tx *bolt.Tx) error {
-		return tx.Bucket([]byte("User")).ForEach(func(k []byte, v []byte) error {
-			if len(v) > 0 && string(v)[0] == '{' {
-				user := &oldUser{}
-				err := json.Unmarshal(v, user)
-
-				if err != nil {
-					return err
-				}
-
-				oldUsers = append(oldUsers, user)
-			}
-
-			return nil
-		})
-	})
-
-	return oldUsers, err
-}
-
-func convertUsersToNew(old []*oldUser) ([]*users.User, error) {
-	list := []*users.User{}
-
-	for _, oldUser := range old {
-		user := &users.User{
-			Username:     oldUser.Username,
-			Password:     oldUser.Password,
-			Scope:        oldUser.Scope,
-			Locale:       oldUser.Locale,
-			LockPassword: oldUser.LockPassword,
-			ViewMode:     users.ViewMode(oldUser.ViewMode),
-			Commands:     oldUser.Commands,
-			Rules:        []rules.Rule{},
-			Perm: users.Permissions{
-				Admin:    oldUser.Admin,
-				Execute:  oldUser.AllowCommands,
-				Create:   oldUser.AllowNew,
-				Rename:   oldUser.AllowEdit,
-				Modify:   oldUser.AllowEdit,
-				Delete:   oldUser.AllowEdit,
-				Share:    true,
-				Download: true,
-			},
-		}
-
-		for _, rule := range oldUser.Rules {
-			user.Rules = append(user.Rules, *rule)
-		}
-
-		err := user.Clean("")
-		if err != nil {
-			return nil, err
-		}
-
-		list = append(list, user)
-	}
-
-	return list, nil
-}
-
-func importUsers(old *storm.DB, sto *storage.Storage) error {
-	oldUsers, err := readOldUsers(old)
-	if err != nil {
-		return err
-	}
-
-	newUsers, err := convertUsersToNew(oldUsers)
-	if err != nil {
-		return err
-	}
-
-	for _, user := range newUsers {
-		err = sto.Users.Save(user)
-		if err != nil {
-			return err
-		}
-	}
-
-	fmt.Printf("%d users successfully imported into the new DB.\n", len(newUsers))
-	return nil
-}

backend/storage/bolt/users.go

@@ -45,11 +45,9 @@ func (st usersBackend) Gets() ([]*users.User, error) {
 	if err == storm.ErrNotFound {
 		return nil, errors.ErrNotExist
 	}
-
 	if err != nil {
 		return allUsers, err
 	}
-
 	return allUsers, err
 }
 
@@ -57,7 +55,6 @@ func (st usersBackend) Update(user *users.User, fields ...string) error {
 	if len(fields) == 0 {
 		return st.Save(user)
 	}
-
 	for _, field := range fields {
 		userField := reflect.ValueOf(user).Elem().FieldByName(field)
 		if !userField.IsValid() {
@@ -65,15 +62,19 @@ func (st usersBackend) Update(user *users.User, fields ...string) error {
 		}
 		val := userField.Interface()
 		if err := st.db.UpdateField(user, field, val); err != nil {
-			return err
+			return fmt.Errorf("Error updating user field: %s, error: %v", field, err.Error())
 		}
 	}
-
 	return nil
 }
 
 func (st usersBackend) Save(user *users.User) error {
-	err := st.db.Save(user)
+	pass, err := users.HashPwd(user.Password)
+	if err != nil {
+		return err
+	}
+	user.Password = pass
+	err = st.db.Save(user)
 	if err == storm.ErrAlreadyExists {
 		return errors.ErrExist
 	}