Add Finnish translation

* Add Persian translation

* Update cs.json (POEditor.com)

* Update fr.json (POEditor.com)

* Update ja.json (POEditor.com)

* Update pt.json (POEditor.com)

* Update ru.json (POEditor.com)

* Update sl.json (POEditor.com)

* Fix "Shared Playlists" pt translation

* Update de.json (POEditor.com)

* Update it.json (POEditor.com)

* Update sl.json (POEditor.com)

* Update es.json (POEditor.com)

* Update zh-Hant.json (POEditor.com)

* Update th.json (POEditor.com)

.devcontainer/Dockerfile

@@ -0,0 +1,20 @@
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.148.1/containers/go/.devcontainer/base.Dockerfile
+
+# [Choice] Go version: 1, 1.15, 1.14
+ARG VARIANT="1"
+FROM mcr.microsoft.com/vscode/devcontainers/go:0-${VARIANT}
+
+# [Option] Install Node.js
+ARG INSTALL_NODE="true"
+ARG NODE_VERSION="lts/*"
+RUN if [ "${INSTALL_NODE}" = "true" ]; then su vscode -c "source /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi
+
+# [Optional] Uncomment this section to install additional OS packages.
+RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
+    && apt-get -y install --no-install-recommends libtag1-dev ffmpeg
+
+# [Optional] Uncomment the next line to use go get to install anything else you need
+# RUN go get -x <your-dependency-or-tool>
+
+# [Optional] Uncomment this line to install global node packages.
+# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1

.devcontainer/devcontainer.json

@@ -0,0 +1,59 @@
+{
+	"name": "Go",
+	"build": {
+		"dockerfile": "Dockerfile",
+		"args": {
+			// Update the VARIANT arg to pick a version of Go: 1, 1.15, 1.14
+			"VARIANT": "1.17",
+			// Options
+			"INSTALL_NODE": "true",
+			"NODE_VERSION": "v16"
+		}
+	},
+	"runArgs": [
+		"--cap-add=SYS_PTRACE",
+		"--security-opt",
+		"seccomp=unconfined"
+	],
+	// Set *default* container specific settings.json values on container create.
+	"settings": {
+		"terminal.integrated.shell.linux": "/bin/bash",
+		"go.useGoProxyToCheckForToolUpdates": false,
+		"go.useLanguageServer": true,
+		"go.gopath": "/go",
+		"go.goroot": "/usr/local/go",
+		"go.toolsGopath": "/go/bin",
+		"go.formatTool": "goimports",
+		"go.lintOnSave": "package",
+		"go.lintTool": "golangci-lint",
+		"editor.formatOnSave": true,
+		"[javascript]": {
+			"editor.defaultFormatter": "esbenp.prettier-vscode"
+		},
+		"[json]": {
+			"editor.defaultFormatter": "esbenp.prettier-vscode"
+		},
+		"[jsonc]": {
+			"editor.defaultFormatter": "vscode.json-language-features"
+		}
+	},
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"golang.Go",
+		"esbenp.prettier-vscode",
+		"tamasfe.even-better-toml"
+	],
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	"forwardPorts": [
+		4533,
+		4633
+	],
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "make setup-dev",
+	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "vscode",
+	"remoteEnv": {
+		"ND_MUSICFOLDER": "./music",
+		"ND_DATAFOLDER": "./data"
+	}
+}

.dockerignore

@@ -8,5 +8,3 @@ testDB
 navidrome
 navidrome.db
 navidrome.toml
-assets/*gen.go
-

.git-blame-ignore-revs

@@ -1,2 +1,4 @@
 # Upgrade Prettier to 2.0.4. Reformatted all JS files
 b3f70538a9138bc279a451f4f358605097210d41
+# Move project to Navidrome GitHub organization
+6ee45a9ccc5e7ea4290c89030e67c99c0514bd25

.github/FUNDING.yml

@@ -3,8 +3,8 @@
 github: deluan
 patreon: # Replace with a single Patreon username
 open_collective: # Replace with a single Open Collective username
-liberapay: deluan
 ko_fi: deluan
+liberapay: deluan
 tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 issuehunt: # Replace with a single IssueHunt username

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,37 @@
+---
+name: Bug Report
+about: Use this template for submitting a bug report.
+title: ""
+labels: bug
+assignees: ""
+---
+<!-- Please check that another issue for the same bug has not been already made by searching the [issues](https://github.com/navidrome/navidrome/issues) -->
+
+### Description
+
+A clear and concise description of what the bug is.
+
+### Expected Behaviour
+
+What you would have expected to happen instead.
+
+### Steps to reproduce
+
+1. Open the '...'
+2. Click on '...'
+3. Scroll down to '...'
+4. See error
+
+### Platform information
+
+ - Navidrome version: <!-- e.g. v0.40.0 -->
+ - Browser and version: <!-- e.g. Firefox v87.0b9 -->
+ - Operating System: <!-- e.g. Ubuntu 20.04 and whether using a binary, docker or built from source  -->
+
+### Additional information
+
+Any other information that may be relevant or give context to the problem.
+
+ - Screenshots (if applicable)?
+ - Logs? <!-- Turn the log level up to trace -->
+ - Client used? <!-- e.g. DSub v5.5.2R2 -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,24 @@
+---
+name: Feature Request
+about: Use this template to request for a feature.
+title: ""
+labels: enhancement
+assignees: ""
+---
+<!-- Please check that another issue for the same feature request has not been already made by searching the [issues](https://github.com/navidrome/navidrome/issues) -->
+
+### Is your feature request related to a problem? Please describe.
+
+A clear and concise description of what the problem is. For e.g. I'm always frustrated when '...'
+
+### Describe the solution you'd like
+
+A clear and concise description of what you would like to happen.
+
+### Describe alternative solutions that would also satisfy this problem
+
+A clear and concise description of any alternative solutions or features you've considered.
+
+### Additional context
+
+Add any other context or screenshots about the feature request here.

.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/ui"
+  schedule:
+    interval: weekly
+  open-pull-requests-limit: 10
+- package-ecosystem: gomod
+  directory: "/"
+  schedule:
+    interval: weekly
+  open-pull-requests-limit: 10

.github/workflows/pipeline.dockerfile

@@ -7,6 +7,7 @@ RUN echo "Target Platform = ${TARGETPLATFORM}"
 
 COPY dist .
 RUN if [ "$TARGETPLATFORM" = "linux/amd64" ];  then cp navidrome_linux_amd64_linux_amd64/navidrome /navidrome; fi
+RUN if [ "$TARGETPLATFORM" = "linux/386" ];  then cp navidrome_linux_386_linux_386/navidrome /navidrome; fi
 RUN if [ "$TARGETPLATFORM" = "linux/arm64" ];  then cp navidrome_linux_arm64_linux_arm64/navidrome /navidrome; fi
 RUN if [ "$TARGETPLATFORM" = "linux/arm/v6" ]; then cp navidrome_linux_arm_linux_arm_6/navidrome /navidrome; fi
 RUN if [ "$TARGETPLATFORM" = "linux/arm/v7" ]; then cp navidrome_linux_arm_linux_arm_7/navidrome /navidrome; fi

.github/workflows/pipeline.yml

@@ -9,78 +9,104 @@ on:
     branches:
       - master
 jobs:
-  golangci-lint:
-    name: Lint Server
+  go-lint:
+    name: Lint Go code
     runs-on: ubuntu-latest
     steps:
       - name: Install taglib
         run: sudo apt-get install libtag1-dev
 
+      - name: Set up Go 1.17
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.17
+        id: go
+
       - uses: actions/checkout@v2
 
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v1
+        uses: golangci/golangci-lint-action@v2
         with:
-          version: v1.27
+          version: v1.40
           github-token: ${{ secrets.GITHUB_TOKEN }}
           args: --timeout 2m
 
+      - name: Install goimports
+        run: go install golang.org/x/tools/cmd/goimports
+
+      - run: goimports -w `find . -name '*.go' | grep -v '_gen.go$'`
+      - run: go mod tidy
+      - name: Verify no changes from goimports and go mod tidy
+        run: |
+          git status --porcelain
+          if [ -n "$(git status --porcelain)" ]; then
+            exit 1
+          fi
+
   go:
-    name: Test Server
+    name: Test with Go ${{ matrix.go_version }}
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go_version: [1.16.x, 1.17.x]
     steps:
       - name: Install taglib
         run: sudo apt-get install libtag1-dev
 
-      - name: Set up Go 1.14
-        uses: actions/setup-go@v1
+      - name: Set up Go ${{ matrix.go_version }}
+        uses: actions/setup-go@v2
         with:
-          go-version: 1.14
+          stable: '!contains(${{ matrix.go_version }}, "beta") && !contains(${{ matrix.go_version }}, "rc")'
+          go-version: ${{ matrix.go_version }}
         id: go
 
       - name: Check out code into the Go module directory
         uses: actions/checkout@v2
 
-      - uses: actions/cache@v1
+      - uses: actions/cache@v2
         id: cache-go
         with:
           path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          key: ${{ runner.os }}-go-${{ matrix.go_version }}-${{ hashFiles('**/go.sum') }}
           restore-keys: |
-            ${{ runner.os }}-go-
+            ${{ runner.os }}-go-${{ matrix.go_version }}-
 
       - name: Download dependencies
         if: steps.cache-go.outputs.cache-hit != 'true'
+        continue-on-error: ${{contains(matrix.go_version, 'beta') || contains(matrix.go_version, 'rc')}}
         run: go mod download
 
       - name: Test
+        continue-on-error: ${{contains(matrix.go_version, 'beta') || contains(matrix.go_version, 'rc')}}
         run: go test -cover ./... -v
+
   js:
     name: Build JS bundle
     runs-on: ubuntu-latest
+    env:
+      NODE_OPTIONS: '--max_old_space_size=4096'
     steps:
       - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v2
         with:
-          node-version: 14
-
-      - uses: actions/cache@v1
-        id: cache-npm
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-${{ hashFiles('ui/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
+          node-version: 16
+          cache: 'npm'
+          cache-dependency-path: '**/package-lock.json'
 
       - name: npm install dependencies
         run: |
           cd ui
           npm ci
 
-      - name: npm check-formatting
+      - name: npm lint
         run: |
           cd ui
-          npm run check-formatting
+          npm run check-formatting && npm run lint
+
+      - name: npm test
+        run: |
+          cd ui
+          npm test
 
       - name: npm build
         run: |
@@ -91,10 +117,11 @@ jobs:
         with:
           name: js-bundle
           path: ui/build
+          retention-days: 7
 
   binaries:
-    name: Binaries
-    needs: [js]
+    name: Build binaries
+    needs: [js, go, go-lint]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Code
@@ -115,7 +142,7 @@ jobs:
 
       - name: Run GoReleaser - SNAPSHOT
         if: startsWith(github.ref, 'refs/tags/') != true
-        uses: docker://deluan/ci-goreleaser:1.14.9-4
+        uses: docker://deluan/ci-goreleaser:1.17.1-1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
@@ -123,7 +150,7 @@ jobs:
 
       - name: Run GoReleaser - RELEASE
         if: startsWith(github.ref, 'refs/tags/')
-        uses: docker://deluan/ci-goreleaser:1.14.9-4
+        uses: docker://deluan/ci-goreleaser:1.17.1-1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
@@ -136,23 +163,26 @@ jobs:
             dist
             !dist/*.tar.gz
             !dist/*.zip
+          retention-days: 7
 
   docker:
-    name: Docker images
+    name: Build Docker images
     needs: [binaries]
     runs-on: ubuntu-latest
     env:
       DOCKER_IMAGE: ${{secrets.DOCKER_IMAGE}}
     steps:
+      - name: Set up QEMU
+        id: qemu
+        uses: docker/setup-qemu-action@v1
+        if: env.DOCKER_IMAGE != ''
+
       - name: Set up Docker Buildx
         id: buildx
-        uses: crazy-max/ghaction-docker-buildx@v1
+        uses: docker/setup-buildx-action@v1
         if: env.DOCKER_IMAGE != ''
-        with:
-          buildx-version: latest
-          qemu-version: latest
 
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v2
         if: env.DOCKER_IMAGE != ''
 
       - uses: actions/download-artifact@v2
@@ -165,7 +195,7 @@ jobs:
         if: env.DOCKER_IMAGE != ''
         env:
           DOCKER_IMAGE: ${{secrets.DOCKER_IMAGE}}
-          DOCKER_PLATFORM: linux/amd64,linux/arm/v7,linux/arm64
+          DOCKER_PLATFORM: linux/amd64,linux/386,linux/arm/v6,linux/arm/v7,linux/arm64
         run: |
           echo ${{secrets.DOCKER_PASSWORD}} | docker login -u ${{secrets.DOCKER_USERNAME}} --password-stdin
           docker buildx build --platform ${DOCKER_PLATFORM} `.github/workflows/docker-tags.sh` -f .github/workflows/pipeline.dockerfile --push .

.github/workflows/remove-old-artifacts.yml

@@ -1,18 +0,0 @@
-name: Remove old artifacts
-
-on:
-  schedule:
-    # Every day at 1am
-    - cron: '0 1 * * *'
-
-jobs:
-  remove-old-artifacts:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-
-    steps:
-      - name: Remove old artifacts
-        uses: c-hive/gha-remove-artifacts@v1
-        with:
-          age: '7 days'
-          skip-tags: false

.gitignore

@@ -22,4 +22,4 @@ docker-compose.yml
 navidrome.db-shm
 navidrome.db-wal
 tags
-
+.gitinfo

.golangci.yml

@@ -2,10 +2,10 @@ linters:
   enable:
     - bodyclose
     - deadcode
+    - depguard
     - dogsled
     - errcheck
     - gocyclo
-    - goimports
     - goprintffuncname
     - gosec
     - gosimple
@@ -26,4 +26,4 @@ issues:
   exclude-rules:
     - linters:
         - gosec
-      text: "(G501|G401):"
+      text: "(G501|G401|G505):"

.goreleaser.yml

@@ -1,11 +1,6 @@
 # GoReleaser config
 project_name: navidrome
 
-before:
-  hooks:
-    - go-bindata -fs -prefix resources -tags embed -ignore="\\\*.go" -pkg resources -o resources/embedded_gen.go resources/...
-    - go-bindata -fs -prefix ui/build -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/...
-
 builds:
   - id: navidrome_linux_amd64
     env:
@@ -15,10 +10,10 @@ builds:
     goarch:
       - amd64
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static -lz'"
-      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_linux_386
     env:
@@ -28,10 +23,10 @@ builds:
     goarch:
       - 386
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static'"
-      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_linux_arm
     env:
@@ -47,10 +42,10 @@ builds:
       - 6
       - 7
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static'"
-      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_linux_arm64
     env:
@@ -62,12 +57,12 @@ builds:
     goarch:
       - arm64
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static'"
-      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
-  - id: navidrome_windows_i686
+  - id: navidrome_windows_386
     env:
       - CGO_ENABLED=1
       - CC=i686-w64-mingw32-gcc
@@ -78,12 +73,12 @@ builds:
     goarch:
       - 386
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static'"
-      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
-  - id: navidrome_windows_x64
+  - id: navidrome_windows_amd64
     env:
       - CGO_ENABLED=1
       - CC=x86_64-w64-mingw32-gcc
@@ -94,12 +89,12 @@ builds:
     goarch:
       - amd64
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static'"
-      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
-  - id: navidrome_darwin
+  - id: navidrome_darwin_amd64
     env:
       - CGO_ENABLED=1
       - CC=o64-clang
@@ -110,9 +105,9 @@ builds:
     goarch:
       - amd64
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
-      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
 archives:
   - format_overrides:

.nvmrc

@@ -1 +1 @@
-v14
+v16

CONTRIBUTING.md

@@ -0,0 +1,92 @@
+# Navidrome Contribution Guide
+
+Navidrome is a streaming service which allows you to enjoy your music collection from anywhere. We'd welcome you to contribute to our open source project and make Navidrome even better. There are some basic guidelines which you need to follow if you like to contribute to Navidrome.
+
+- [Code of Conduct](#code-of-conduct)
+- [Issues](#issues)
+- [Questions](#questions)
+- [Pull Requests](#pull-requests)
+
+
+## Code of Conduct
+Please read the following [Code of Conduct](https://github.com/navidrome/navidrome/blob/master/CODE_OF_CONDUCT.md).
+
+## Issues
+Found any issue or bug in our codebase? Have a great idea you want to propose or discuss with 
+the developers? You can help by submitting an [issue](https://github.com/navidrome/navidrome/issues/new/choose)
+to the Github repository. 
+
+**Before opening a new issue, please check if the issue has not been already made by searching 
+the [issues](https://github.com/navidrome/navidrome/issues)**
+
+## Questions
+We would like to have discussions and general queries related to Navidrome on our [Discord channel](https://discord.gg/2qMuMyHfSV).
+
+## Pull requests
+Before submitting a pull request, ensure that you go through the following:
+- Open a corresponding issue for the Pull Request, if not existing. The issue can be opened following [these guidelines](#issues)
+- Ensure that there is no open or closed Pull Request corresponding to your submission to avoid duplication of effort.
+- Setup the [development environment](https://www.navidrome.org/docs/developers/dev-environment/)
+- Create a new branch on your forked repo and make the changes in it. Naming conventions for branch are: `<Issue Title>/<Issue Number>`. Example:
+```
+    git checkout -b adding-docs/834 master
+```
+- The commits should follow a [specific convention](#commit-conventions)
+- Ensure that a DCO sign-off for commits is provided via `--signoff` option of git commit
+- Provide a link to the issue that will be closed via your Pull request.
+
+### Commit Conventions
+Each commit message must adhere to the following format:
+```
+<type>(scope): <description> - <issue number>
+
+[optional body]
+```
+This improves the readability of the messages
+
+#### Type
+It can be one of the following:
+1. **feat**: Addition of a new feature
+2. **fix**: Bug fix
+3. **docs**: Documentation Changes
+4. **style**: Changes to styling
+5. **refactor**: Refactoring of code
+6. **perf**: Code that affects performance
+7. **test**: Updating or improving the current tests
+8. **build**: Changes to Build process
+9. **revert**: Reverting to a previous commit 
+10. **chore** : updating grunt tasks etc
+
+If there is a breaking change in your Pull Request, please add `BREAKING CHANGE` in the optional body section
+
+#### Scope
+The file or folder where the changes are made. If there are more than one, you can mention any
+
+#### Description
+A short description of the issue
+
+#### Issue number
+The issue fixed by this Pull Request.
+
+The body is optional. It may contain short description of changes made.
+
+Following all the guidelines an ideal commit will look like:
+```
+    git commit --signoff -m "feat(themes): New-theme - #834"
+```
+
+After committing, push your commits to your forked branch and create a Pull Request from there.
+The Pull Request Title can be the same as `<type>(scope): <description> - <issue number>`
+A demo layout of how the Pull request body can look:
+```
+Closes <Issue number along with link>
+
+Description (What does the pull request do)
+
+Changes (What changes were made )
+
+Screenshots or Videos
+
+Related Issues and Pull Requests(if any)
+
+```

Makefile

@@ -1,97 +1,104 @@
 GO_VERSION=$(shell grep "^go " go.mod | cut -f 2 -d ' ')
 NODE_VERSION=$(shell cat .nvmrc)
 
+ifneq ("$(wildcard .git)","")
 GIT_SHA=$(shell git rev-parse --short HEAD)
 GIT_TAG=$(shell git describe --tags `git rev-list --tags --max-count=1`)
+else
+GIT_SHA=source_archive
+GIT_TAG=$(patsubst navidrome-%,v%,$(notdir $(PWD)))
+endif
 
-## Default target just build the Go project.
-default:
-	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=master"
-.PHONY: default
+CI_RELEASER_VERSION=1.17.1-1 ## https://github.com/navidrome/ci-goreleaser
 
-dev: check_env
-	npx foreman -j Procfile.dev -p 4533 start
-.PHONY: dev
-
-server: check_go_env
-	@reflex -d none -c reflex.conf
-.PHONY: server
-
-wire: check_go_env
-	wire ./...
-.PHONY: wire
-
-watch: check_go_env
-	ginkgo watch -notify ./...
-.PHONY: watch
-
-test: check_go_env
-	go test ./... -v
-.PHONY: test
-
-testall: check_go_env test
-	@(cd ./ui && npm test -- --watchAll=false)
-.PHONY: testall
-
-update-snapshots: check_go_env
-	UPDATE_SNAPSHOTS=true ginkgo ./server/subsonic/...
-.PHONY: update-snapshots
-
-migration:
-	@if [ -z "${name}" ]; then echo "Usage: make migration name=name_of_migration_file"; exit 1; fi
-	goose -dir db/migrations create ${name}
-.PHONY: migration
-
-setup:
-	@which go-bindata || (echo "Installing BinData"  && GO111MODULE=off go get -u github.com/go-bindata/go-bindata/...)
-	go mod download
+setup: check_env download-deps setup-git ##@1_Run_First Install dependencies and prepare development environment
+	@echo Downloading Node dependencies...
 	@(cd ./ui && npm ci)
 .PHONY: setup
 
-setup-dev: setup setup-git
-	@which wire          || (echo "Installing Wire"          && GO111MODULE=off go get -u github.com/google/wire/cmd/wire)
-	@which ginkgo        || (echo "Installing Ginkgo"        && GO111MODULE=off go get -u github.com/onsi/ginkgo/ginkgo)
-	@which goose         || (echo "Installing Goose"         && GO111MODULE=off go get -u github.com/pressly/goose/cmd/goose)
-	@which reflex        || (echo "Installing Reflex"        && GO111MODULE=off go get -u github.com/cespare/reflex)
-	@which golangci-lint || (echo "Installing GolangCI-Lint" && cd .. && GO111MODULE=on go get github.com/golangci/golangci-lint/cmd/golangci-lint@v1.27.0)
-	@which goimports     || (echo "Installing goimports"     && GO111MODULE=off go get -u golang.org/x/tools/cmd/goimports)
+dev: check_env   ##@Development Start Navidrome in development mode, with hot-reload for both frontend and backend
+	npx foreman -j Procfile.dev -p 4533 start
+.PHONY: dev
+
+server: check_go_env  ##@Development Start the backend in development mode
+	@go run github.com/cespare/reflex -d none -c reflex.conf
+.PHONY: server
+
+watch: ##@Development Start Go tests in watch mode (re-run when code changes)
+	go run github.com/onsi/ginkgo/ginkgo watch -notify ./...
+.PHONY: watch
+
+test: ##@Development Run Go tests
+	go test ./...
+.PHONY: test
+
+testall: test ##@Development Run Go and JS tests
+	@(cd ./ui && npm test -- --watchAll=false)
+.PHONY: testall
+
+lint: ##@Development Lint Go code
+	go run github.com/golangci/golangci-lint/cmd/golangci-lint run -v --timeout 5m
+.PHONY: lint
+
+lintall: lint ##@Development Lint Go and JS code
+	@(cd ./ui && npm run check-formatting && npm run lint)
+.PHONY: lintall
+
+wire: check_go_env ##@Development Update Dependency Injection
+	go run github.com/google/wire/cmd/wire ./...
+.PHONY: wire
+
+snapshots: ##@Development Update (GoLang) Snapshot tests
+	UPDATE_SNAPSHOTS=true go run github.com/onsi/ginkgo/ginkgo ./server/subsonic/...
+.PHONY: snapshots
+
+migration: ##@Development Create an empty migration file
+	@if [ -z "${name}" ]; then echo "Usage: make migration name=name_of_migration_file"; exit 1; fi
+	go run github.com/pressly/goose/cmd/goose -dir db/migration create ${name}
+.PHONY: migration
+
+setup-dev: setup
 .PHONY: setup-dev
 
-setup-git:
+setup-git: ##@Development Setup Git hooks (pre-commit and pre-push)
+	@echo Setting up git hooks
 	@mkdir -p .git/hooks
-	(cd .git/hooks && ln -sf ../../git/* .)
+	@(cd .git/hooks && ln -sf ../../git/* .)
 .PHONY: setup-git
 
-check_env: check_go_env check_node_env
-.PHONY: check_env
-
-check_go_env:
-	@(hash go) || (echo "\nERROR: GO environment not setup properly!\n"; exit 1)
-	@go version | grep -q $(GO_VERSION) || (echo "\nERROR: Please upgrade your GO version\nThis project requires version $(GO_VERSION)"; exit 1)
-.PHONY: check_go_env
-
-check_node_env:
-	@(hash node) || (echo "\nERROR: Node environment not setup properly!\n"; exit 1)
-	@node --version | grep -q $(NODE_VERSION) || (echo "\nERROR: Please check your Node version. Should be $(NODE_VERSION)\n"; exit 1)
-.PHONY: check_node_env
-
-build: check_go_env
-	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT"
-.PHONY: build
-
-buildall: check_env
-	@(cd ./ui && npm run build)
-	go-bindata -fs -prefix "resources" -tags embed -ignore="\\\*.go" -pkg resources -o resources/embedded_gen.go resources/...
-	go-bindata -fs -prefix "ui/build" -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/...
-	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT" -tags=embed
+buildall: buildjs build ##@Build Build the project, both frontend and backend
 .PHONY: buildall
 
-pre-push:
-	golangci-lint run -v
+build: check_go_env  ##@Build Build only backend
+	@echo "WARNING: This command does not build the frontend, it uses the latest one built by 'make buildjs'"
+	go build -ldflags="-X github.com/navidrome/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/navidrome/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT" -tags=netgo
+.PHONY: build
 
-	@echo
-	make test
-.PHONY: pre-push
+buildjs: check_node_env ##@Build Build only frontend
+	@(cd ./ui && npm run build)
+.PHONY: buildjs
+
+all: ##@Cross_Compilation Build binaries for all supported platforms. It does not build the frontend
+	@echo "WARNING: This command does not builds the frontend, it uses the latest one built by 'make buildjs'"
+	docker run -t -v $(PWD):/workspace -w /workspace deluan/ci-goreleaser:$(CI_RELEASER_VERSION) \
+ 		goreleaser release --rm-dist --skip-publish --snapshot
+.PHONY: all
+
+single: ##@Cross_Compilation Build binaries for a single supported platforms. It does not build the frontend
+	@echo "WARNING: This command does not build the frontend, it uses the latest one built by 'make buildjs'"
+	@if [ -z "${GOOS}" -o -z "${GOARCH}" ]; then \
+		echo "Usage: GOOS=<os> GOARCH=<arch> make single"; \
+		echo "Options:"; \
+		grep -- "- id: navidrome_" .goreleaser.yml | sed 's/- id: navidrome_//g'; \
+		exit 1; \
+	fi
+	@echo "Building binaries for ${GOOS}/${GOARCH}"
+	docker run -t -v $(PWD):/workspace -e GOOS -e GOARCH -w /workspace deluan/ci-goreleaser:$(CI_RELEASER_VERSION) \
+ 		goreleaser build --rm-dist --snapshot --single-target --id navidrome_${GOOS}_${GOARCH}
+.PHONY: single
+
+##########################################
+#### Miscellaneous
 
 release:
 	@if [[ ! "${V}" =~ ^[0-9]+\.[0-9]+\.[0-9]+.*$$ ]]; then echo "Usage: make release V=X.X.X"; exit 1; fi
@@ -102,6 +109,44 @@ release:
 	git push origin v${V} --no-verify
 .PHONY: release
 
-snapshot:
-	 docker run -it -v $(PWD):/workspace -w /workspace deluan/ci-goreleaser:1.14.9-4 goreleaser release --rm-dist --skip-publish --snapshot
-.PHONY: snapshot
+download-deps:
+	@echo Downloading Go dependencies...
+	@go mod download -x
+	@go mod tidy # To revert any changes made by the `go mod download` command
+.PHONY: download-deps
+
+check_env: check_go_env check_node_env
+.PHONY: check_env
+
+check_go_env:
+	@(hash go) || (echo "\nERROR: GO environment not setup properly!\n"; exit 1)
+	@current_go_version=`go version | cut -d ' ' -f 3 | cut -c3-` && \
+		echo "$(GO_VERSION) $$current_go_version" | \
+		tr ' ' '\n' | sort -V | tail -1 | \
+		grep -q "^$${current_go_version}$$" || \
+		(echo "\nERROR: Please upgrade your GO version\nThis project requires at least the version $(GO_VERSION)"; exit 1)
+.PHONY: check_go_env
+
+check_node_env:
+	@(hash node) || (echo "\nERROR: Node environment not setup properly!\n"; exit 1)
+	@current_node_version=`node --version` && \
+		echo "$(NODE_VERSION) $$current_node_version" | \
+		tr ' ' '\n' | sort -V | tail -1 | \
+		grep -q "^$${current_node_version}$$" || \
+		(echo "\nERROR: Please check your Node version. Should be at least $(NODE_VERSION)\n"; exit 1)
+.PHONY: check_node_env
+
+pre-push: lintall testall
+.PHONY: pre-push
+
+.DEFAULT_GOAL := help
+
+HELP_FUN = \
+	%help; while(<>){push@{$$help{$$2//'options'}},[$$1,$$3] \
+	if/^([\w-_]+)\s*:.*\#\#(?:@(\w+))?\s(.*)$$/}; \
+	print"$$_:\n", map"  $$_->[0]".(" "x(20-length($$_->[0])))."$$_->[1]\n",\
+	@{$$help{$$_}},"\n" for sort keys %help; \
+
+help: ##@Miscellaneous Show this help
+	@echo "Usage: make [target] ...\n"
+	@perl -e '$(HELP_FUN)' $(MAKEFILE_LIST)

Procfile.dev

@@ -1,2 +1,2 @@
 JS: sh -c "cd ./ui && npm start"
-GO: reflex -c reflex.conf
+GO: go run github.com/cespare/reflex -d none -c reflex.conf

README.md

@@ -1,12 +1,14 @@
+<img src="resources/logo-192x192.png" alt="Navidrome logo" title="navidrome" align="right" height="60px" />
+
 # Navidrome Music Server
 
-[![Last Release](https://img.shields.io/github/v/release/deluan/navidrome?label=latest&style=flat-square)](https://github.com/deluan/navidrome/releases)
-[![Build](https://img.shields.io/github/workflow/status/deluan/navidrome/Build?style=flat-square)](https://github.com/deluan/navidrome/actions)
-[![Downloads](https://img.shields.io/github/downloads/deluan/navidrome/total)](https://github.com/deluan/navidrome/releases/latest)
-[![Docker Pulls](https://img.shields.io/docker/pulls/deluan/navidrome?style=flat-square)](https://hub.docker.com/r/deluan/navidrome)
-[![Dev Chat](https://img.shields.io/discord/671335427726114836?label=chat&style=flat-square)](https://discord.gg/xh7j7yF)
-[![Subreddit](https://img.shields.io/reddit/subreddit-subscribers/navidrome?style=flat-square)](https://www.reddit.com/r/navidrome/)
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0-ff69b4.svg)](code_of_conduct.md)
+[![Last Release](https://img.shields.io/github/v/release/navidrome/navidrome?logo=github&label=latest&style=flat-square)](https://github.com/navidrome/navidrome/releases)
+[![Build](https://img.shields.io/github/workflow/status/navidrome/navidrome/Build?logo=github&style=flat-square)](https://nightly.link/navidrome/navidrome/workflows/pipeline/master)
+[![Downloads](https://img.shields.io/github/downloads/navidrome/navidrome/total?logo=github&style=flat-square)](https://github.com/navidrome/navidrome/releases/latest)
+[![Docker Pulls](https://img.shields.io/docker/pulls/deluan/navidrome?logo=docker&label=pulls&style=flat-square)](https://hub.docker.com/r/deluan/navidrome)
+[![Dev Chat](https://img.shields.io/discord/671335427726114836?logo=discord&label=discord&style=flat-square)](https://discord.gg/xh7j7yF)
+[![Subreddit](https://img.shields.io/reddit/subreddit-subscribers/navidrome?logo=reddit&label=/r/navidrome&style=flat-square)](https://www.reddit.com/r/navidrome/)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0-ff69b4.svg?style=flat-square)](CODE_OF_CONDUCT.md)
 
 ## [Check out our Live Demo!](https://www.navidrome.org/demo/)
 
@@ -14,7 +16,7 @@ Navidrome is an open source web-based music collection server and streamer. It g
 music collection from any browser or mobile device. It's like your personal Spotify!
 
 __Any feedback is welcome!__ If you need/want a new feature, find a bug or think of any way to improve Navidrome, 
-please file a [GitHub issue](https://github.com/deluan/navidrome/issues) or join the discussion in our 
+please file a [GitHub issue](https://github.com/navidrome/navidrome/issues) or join the discussion in our 
 [Subreddit](https://www.reddit.com/r/navidrome/). If you want to contribute to the project in any other way 
 ([ui/backend dev](https://www.navidrome.org/docs/developers/), 
 [translations](https://www.navidrome.org/docs/developers/translations/), 
@@ -56,8 +58,8 @@ Here are some useful direct links:
 ## Screenshots
 
 <p align="left">
-    <img height="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-login.png">
-    <img height="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-player.png">
-    <img height="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-album-view.png">
-    <img width="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-desktop-player.png">
+    <img height="550" src="https://raw.githubusercontent.com/navidrome/navidrome/master/.github/screenshots/ss-mobile-login.png">
+    <img height="550" src="https://raw.githubusercontent.com/navidrome/navidrome/master/.github/screenshots/ss-mobile-player.png">
+    <img height="550" src="https://raw.githubusercontent.com/navidrome/navidrome/master/.github/screenshots/ss-mobile-album-view.png">
+    <img width="550" src="https://raw.githubusercontent.com/navidrome/navidrome/master/.github/screenshots/ss-desktop-player.png">
 </p>

assets/external.go

@@ -1,19 +0,0 @@
-// +build !embed
-
-package assets
-
-import (
-	"net/http"
-	"sync"
-
-	"github.com/deluan/navidrome/log"
-)
-
-var once sync.Once
-
-func AssetFile() http.FileSystem {
-	once.Do(func() {
-		log.Warn("Using external assets from 'ui/build' folder")
-	})
-	return http.Dir("ui/build")
-}

cmd/root.go

@@ -1,12 +1,17 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
+	"time"
 
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/consts"
-	"github.com/deluan/navidrome/db"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/db"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/scheduler"
+	"github.com/oklog/run"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 )
@@ -24,7 +29,7 @@ Complete documentation is available at https://www.navidrome.org/docs`,
 			preRun()
 		},
 		Run: func(cmd *cobra.Command, args []string) {
-			startServer()
+			runNavidrome()
 		},
 		Version: consts.Version(),
 	}
@@ -45,20 +50,116 @@ func preRun() {
 	conf.Load()
 }
 
-func startServer() {
+func runNavidrome() {
 	db.EnsureLatestVersion()
 
-	subsonic, err := CreateSubsonicAPIRouter()
-	if err != nil {
-		panic(fmt.Sprintf("Could not create the Subsonic API router. Aborting! err=%v", err))
+	var g run.Group
+
+	g.Add(startServer())
+	g.Add(startSignaler())
+	g.Add(startScheduler())
+
+	schedule := conf.Server.ScanSchedule
+	if schedule != "" {
+		go schedulePeriodicScan(schedule)
+	} else {
+		log.Warn("Periodic scan is DISABLED")
+	}
+
+	if err := g.Run(); err != nil {
+		log.Error("Fatal error in Navidrome. Aborting", err)
 	}
-	a := CreateServer(conf.Server.MusicFolder)
-	a.MountRouter(consts.URLPathSubsonicAPI, subsonic)
-	a.MountRouter(consts.URLPathUI, CreateAppRouter())
-	a.Run(fmt.Sprintf("%s:%d", conf.Server.Address, conf.Server.Port))
 }
 
-// TODO: Implemement some struct tags to map flags to viper
+func startServer() (func() error, func(err error)) {
+	return func() error {
+			a := CreateServer(conf.Server.MusicFolder)
+			a.MountRouter("Native API", consts.URLPathNativeAPI, CreateNativeAPIRouter())
+			a.MountRouter("Subsonic API", consts.URLPathSubsonicAPI, CreateSubsonicAPIRouter())
+			if conf.Server.LastFM.Enabled {
+				a.MountRouter("LastFM Auth", consts.URLPathNativeAPI+"/lastfm", CreateLastFMRouter())
+			}
+			return a.Run(fmt.Sprintf("%s:%d", conf.Server.Address, conf.Server.Port))
+		}, func(err error) {
+			if err != nil {
+				log.Error("Shutting down Server due to error", err)
+			} else {
+				log.Info("Shutting down Server")
+			}
+		}
+}
+
+var sigChan = make(chan os.Signal, 1)
+
+func startSignaler() (func() error, func(err error)) {
+	scanner := GetScanner()
+	ctx, cancel := context.WithCancel(context.Background())
+
+	return func() error {
+			for {
+				select {
+				case sig := <-sigChan:
+					log.Info(ctx, "Received signal, triggering a new scan", "signal", sig)
+					start := time.Now()
+					err := scanner.RescanAll(ctx, false)
+					if err != nil {
+						log.Error(ctx, "Error scanning", err)
+					}
+					log.Info(ctx, "Triggered scan complete", "elapsed", time.Since(start).Round(100*time.Millisecond))
+				case <-ctx.Done():
+					break
+				}
+			}
+		}, func(err error) {
+			cancel()
+			if err != nil {
+				log.Error("Shutting down Signaler due to error", err)
+			} else {
+				log.Info("Shutting down Signaler")
+			}
+		}
+}
+
+func schedulePeriodicScan(schedule string) {
+	scanner := GetScanner()
+	schedulerInstance := scheduler.GetInstance()
+
+	log.Info("Scheduling periodic scan", "schedule", schedule)
+	err := schedulerInstance.Add(schedule, func() {
+		_ = scanner.RescanAll(context.Background(), false)
+	})
+	if err != nil {
+		log.Error("Error scheduling periodic scan", err)
+	}
+
+	time.Sleep(2 * time.Second) // Wait 2 seconds before the initial scan
+	log.Debug("Executing initial scan")
+	if err := scanner.RescanAll(context.Background(), false); err != nil {
+		log.Error("Error executing initial scan", err)
+	}
+	log.Debug("Finished initial scan")
+}
+
+func startScheduler() (func() error, func(err error)) {
+	log.Info("Starting scheduler")
+	schedulerInstance := scheduler.GetInstance()
+	ctx, cancel := context.WithCancel(context.Background())
+
+	return func() error {
+			schedulerInstance.Run(ctx)
+
+			return nil
+		}, func(err error) {
+			cancel()
+			if err != nil {
+				log.Error("Shutting down Scheduler due to error", err)
+			} else {
+				log.Info("Shutting down Scheduler")
+			}
+		}
+}
+
+// TODO: Implement some struct tags to map flags to viper
 func init() {
 	cobra.OnInitialize(func() {
 		conf.InitConfig(cfgFile)

cmd/scan.go

@@ -1,9 +1,10 @@
 package cmd
 
 import (
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/log"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
 	"github.com/spf13/cobra"
+	"golang.org/x/net/context"
 )
 
 var fullRescan bool
@@ -23,11 +24,10 @@ var scanCmd = &cobra.Command{
 }
 
 func runScanner() {
-	scanner := CreateScanner(conf.Server.MusicFolder)
-	err := scanner.RescanAll(fullRescan)
-	if err != nil {
-		log.Error("Error scanning media folder", "folder", conf.Server.MusicFolder, err)
-	}
+	conf.Server.DevPreCacheAlbumArtwork = false
+
+	scanner := GetScanner()
+	_ = scanner.RescanAll(context.Background(), fullRescan)
 	if fullRescan {
 		log.Info("Finished full rescan")
 	} else {

cmd/signaler_unix.go

@@ -0,0 +1,17 @@
+//go:build !windows && !plan9
+// +build !windows,!plan9
+
+package cmd
+
+import (
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func init() {
+	signals := []os.Signal{
+		syscall.SIGUSR1,
+	}
+	signal.Notify(sigChan, signals...)
+}

cmd/wire_gen.go

@@ -1,59 +1,95 @@
 // Code generated by Wire. DO NOT EDIT.
 
-//go:generate wire
+//go:generate go run github.com/google/wire/cmd/wire
 //+build !wireinject
 
 package cmd
 
 import (
-	"github.com/deluan/navidrome/core"
-	"github.com/deluan/navidrome/core/transcoder"
-	"github.com/deluan/navidrome/persistence"
-	"github.com/deluan/navidrome/scanner"
-	"github.com/deluan/navidrome/server"
-	"github.com/deluan/navidrome/server/app"
-	"github.com/deluan/navidrome/server/subsonic"
-	"github.com/deluan/navidrome/server/subsonic/engine"
 	"github.com/google/wire"
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/agents/lastfm"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/core/transcoder"
+	"github.com/navidrome/navidrome/db"
+	"github.com/navidrome/navidrome/persistence"
+	"github.com/navidrome/navidrome/scanner"
+	"github.com/navidrome/navidrome/server"
+	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/server/nativeapi"
+	"github.com/navidrome/navidrome/server/subsonic"
+	"sync"
 )
 
 // Injectors from wire_injectors.go:
 
 func CreateServer(musicFolder string) *server.Server {
-	dataStore := persistence.New()
-	scannerScanner := scanner.New(dataStore)
-	serverServer := server.New(scannerScanner, dataStore)
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	serverServer := server.New(dataStore)
 	return serverServer
 }
 
-func CreateScanner(musicFolder string) *scanner.Scanner {
-	dataStore := persistence.New()
-	scannerScanner := scanner.New(dataStore)
-	return scannerScanner
-}
-
-func CreateAppRouter() *app.Router {
-	dataStore := persistence.New()
-	router := app.New(dataStore)
+func CreateNativeAPIRouter() *nativeapi.Router {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	broker := events.GetBroker()
+	share := core.NewShare(dataStore)
+	router := nativeapi.New(dataStore, broker, share)
 	return router
 }
 
-func CreateSubsonicAPIRouter() (*subsonic.Router, error) {
-	dataStore := persistence.New()
-	artworkCache := core.NewImageCache()
+func CreateSubsonicAPIRouter() *subsonic.Router {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	artworkCache := core.GetImageCache()
 	artwork := core.NewArtwork(dataStore, artworkCache)
-	nowPlayingRepository := engine.NewNowPlayingRepository()
-	listGenerator := engine.NewListGenerator(dataStore, nowPlayingRepository)
-	playlists := engine.NewPlaylists(dataStore)
 	transcoderTranscoder := transcoder.New()
-	transcodingCache := core.NewTranscodingCache()
+	transcodingCache := core.GetTranscodingCache()
 	mediaStreamer := core.NewMediaStreamer(dataStore, transcoderTranscoder, transcodingCache)
 	archiver := core.NewArchiver(dataStore)
-	players := engine.NewPlayers(dataStore)
-	router := subsonic.New(artwork, listGenerator, playlists, mediaStreamer, archiver, players, dataStore)
-	return router, nil
+	players := core.NewPlayers(dataStore)
+	agentsAgents := agents.New(dataStore)
+	externalMetadata := core.NewExternalMetadata(dataStore, agentsAgents)
+	scanner := GetScanner()
+	broker := events.GetBroker()
+	playTracker := scrobbler.GetPlayTracker(dataStore, broker)
+	router := subsonic.New(dataStore, artwork, mediaStreamer, archiver, players, externalMetadata, scanner, broker, playTracker)
+	return router
+}
+
+func CreateLastFMRouter() *lastfm.Router {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	router := lastfm.NewRouter(dataStore)
+	return router
+}
+
+func createScanner() scanner.Scanner {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	artworkCache := core.GetImageCache()
+	artwork := core.NewArtwork(dataStore, artworkCache)
+	cacheWarmer := core.NewCacheWarmer(artwork, artworkCache)
+	broker := events.GetBroker()
+	scannerScanner := scanner.New(dataStore, cacheWarmer, broker)
+	return scannerScanner
 }
 
 // wire_injectors.go:
 
-var allProviders = wire.NewSet(engine.Set, core.Set, scanner.New, subsonic.New, app.New, persistence.New)
+var allProviders = wire.NewSet(core.Set, subsonic.New, nativeapi.New, persistence.New, lastfm.NewRouter, events.GetBroker, db.Db)
+
+// Scanner must be a Singleton
+var (
+	onceScanner     sync.Once
+	scannerInstance scanner.Scanner
+)
+
+func GetScanner() scanner.Scanner {
+	onceScanner.Do(func() {
+		scannerInstance = createScanner()
+	})
+	return scannerInstance
+}

cmd/wire_injectors.go

@@ -1,25 +1,31 @@
-//+build wireinject
+//go:build wireinject
+// +build wireinject
 
 package cmd
 
 import (
-	"github.com/deluan/navidrome/core"
-	"github.com/deluan/navidrome/persistence"
-	"github.com/deluan/navidrome/scanner"
-	"github.com/deluan/navidrome/server"
-	"github.com/deluan/navidrome/server/app"
-	"github.com/deluan/navidrome/server/subsonic"
-	"github.com/deluan/navidrome/server/subsonic/engine"
+	"sync"
+
 	"github.com/google/wire"
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/agents/lastfm"
+	"github.com/navidrome/navidrome/db"
+	"github.com/navidrome/navidrome/persistence"
+	"github.com/navidrome/navidrome/scanner"
+	"github.com/navidrome/navidrome/server"
+	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/server/nativeapi"
+	"github.com/navidrome/navidrome/server/subsonic"
 )
 
 var allProviders = wire.NewSet(
-	engine.Set,
 	core.Set,
-	scanner.New,
 	subsonic.New,
-	app.New,
+	nativeapi.New,
 	persistence.New,
+	lastfm.NewRouter,
+	events.GetBroker,
+	db.Db,
 )
 
 func CreateServer(musicFolder string) *server.Server {
@@ -29,16 +35,41 @@ func CreateServer(musicFolder string) *server.Server {
 	))
 }
 
-func CreateScanner(musicFolder string) *scanner.Scanner {
+func CreateNativeAPIRouter() *nativeapi.Router {
 	panic(wire.Build(
 		allProviders,
 	))
 }
 
-func CreateAppRouter() *app.Router {
-	panic(wire.Build(allProviders))
+func CreateSubsonicAPIRouter() *subsonic.Router {
+	panic(wire.Build(
+		allProviders,
+		GetScanner,
+	))
 }
 
-func CreateSubsonicAPIRouter() (*subsonic.Router, error) {
-	panic(wire.Build(allProviders))
+func CreateLastFMRouter() *lastfm.Router {
+	panic(wire.Build(
+		allProviders,
+	))
+}
+
+// Scanner must be a Singleton
+var (
+	onceScanner     sync.Once
+	scannerInstance scanner.Scanner
+)
+
+func GetScanner() scanner.Scanner {
+	onceScanner.Do(func() {
+		scannerInstance = createScanner()
+	})
+	return scannerInstance
+}
+
+func createScanner() scanner.Scanner {
+	panic(wire.Build(
+		allProviders,
+		scanner.New,
+	))
 }

conf/configuration.go

@@ -7,8 +7,10 @@ import (
 	"strings"
 	"time"
 
-	"github.com/deluan/navidrome/consts"
-	"github.com/deluan/navidrome/log"
+	"github.com/kr/pretty"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/robfig/cron/v3"
 	"github.com/spf13/viper"
 )
 
@@ -21,37 +23,80 @@ type configOptions struct {
 	DbPath                  string
 	LogLevel                string
 	ScanInterval            time.Duration
+	ScanSchedule            string
 	SessionTimeout          time.Duration
 	BaseURL                 string
 	UILoginBackgroundURL    string
 	EnableTranscodingConfig bool
+	EnableDownloads         bool
 	TranscodingCacheSize    string
 	ImageCacheSize          string
 	AutoImportPlaylists     bool
+	PlaylistsPath           string
 
-	SearchFullString bool
-	IgnoredArticles  string
-	IndexGroups      string
-	ProbeCommand     string
-	CoverArtPriority string
-	CoverJpegQuality int
-	UIWelcomeMessage string
-	GATrackingID     string
-	AuthRequestLimit int
-	AuthWindowLength time.Duration
+	SearchFullString       bool
+	RecentlyAddedByModTime bool
+	IgnoredArticles        string
+	IndexGroups            string
+	ProbeCommand           string
+	CoverArtPriority       string
+	CoverJpegQuality       int
+	UIWelcomeMessage       string
+	EnableGravatar         bool
+	EnableFavourites       bool
+	EnableStarRating       bool
+	EnableUserEditing      bool
+	DefaultTheme           string
+	EnableCoverAnimation   bool
+	GATrackingID           string
+	EnableLogRedacting     bool
+	AuthRequestLimit       int
+	AuthWindowLength       time.Duration
+	PasswordEncryptionKey  string
+	ReverseProxyUserHeader string
+	ReverseProxyWhitelist  string
 
 	Scanner scannerOptions
 
+	Agents  string
+	LastFM  lastfmOptions
+	Spotify spotifyOptions
+
 	// DevFlags. These are used to enable/disable debugging and incomplete features
 	DevLogSourceLine           bool
+	DevLogLevels               map[string]string
 	DevAutoCreateAdminPassword string
+	DevAutoLoginUsername       string
+	DevPreCacheAlbumArtwork    bool
+	DevFastAccessCoverArt      bool
+	DevActivityPanel           bool
+	DevEnableShare             bool
+	DevSidebarPlaylists        bool
+	DevEnableBufferedScrobble  bool
+	DevShowArtistPage          bool
 }
 
 type scannerOptions struct {
-	Extractor string
+	Extractor       string
+	GenreSeparators string
 }
 
-var Server = &configOptions{}
+type lastfmOptions struct {
+	Enabled  bool
+	ApiKey   string
+	Secret   string
+	Language string
+}
+
+type spotifyOptions struct {
+	ID     string
+	Secret string
+}
+
+var (
+	Server = &configOptions{}
+	hooks  []func()
+)
 
 func LoadFromFile(confFile string) {
 	viper.SetConfigFile(confFile)
@@ -61,12 +106,12 @@ func LoadFromFile(confFile string) {
 func Load() {
 	err := viper.Unmarshal(&Server)
 	if err != nil {
-		fmt.Println("Error parsing config:", err)
+		fmt.Println("FATAL: Error parsing config:", err)
 		os.Exit(1)
 	}
 	err = os.MkdirAll(Server.DataFolder, os.ModePerm)
 	if err != nil {
-		fmt.Println("Error creating data path:", "path", Server.DataFolder, err)
+		fmt.Println("FATAL: Error creating data path:", "path", Server.DataFolder, err)
 		os.Exit(1)
 	}
 	Server.ConfigFile = viper.GetViper().ConfigFileUsed()
@@ -75,8 +120,61 @@ func Load() {
 	}
 
 	log.SetLevelString(Server.LogLevel)
+	log.SetLogLevels(Server.DevLogLevels)
 	log.SetLogSourceLine(Server.DevLogSourceLine)
-	log.Debug("Loaded configuration", "file", Server.ConfigFile, "config", fmt.Sprintf("%#v", Server))
+	log.SetRedacting(Server.EnableLogRedacting)
+
+	if err := validateScanSchedule(); err != nil {
+		os.Exit(1)
+	}
+
+	// Print current configuration if log level is Debug
+	if log.CurrentLevel() >= log.LevelDebug {
+		prettyConf := pretty.Sprintf("Loaded configuration from '%s': %# v", Server.ConfigFile, Server)
+		if Server.EnableLogRedacting {
+			prettyConf = log.Redact(prettyConf)
+		}
+		fmt.Println(prettyConf)
+	}
+
+	// Call init hooks
+	for _, hook := range hooks {
+		hook()
+	}
+}
+
+func validateScanSchedule() error {
+	if Server.ScanInterval != -1 {
+		log.Warn("ScanInterval is DEPRECATED. Please use ScanSchedule. See docs at https://navidrome.org/docs/usage/configuration-options/")
+		if Server.ScanSchedule != "@every 1m" {
+			log.Error("You cannot specify both ScanInterval and ScanSchedule, ignoring ScanInterval")
+		} else {
+			if Server.ScanInterval == 0 {
+				Server.ScanSchedule = ""
+			} else {
+				Server.ScanSchedule = fmt.Sprintf("@every %s", Server.ScanInterval)
+			}
+			log.Warn("Setting ScanSchedule", "schedule", Server.ScanSchedule)
+		}
+	}
+	if Server.ScanSchedule == "0" || Server.ScanSchedule == "" {
+		Server.ScanSchedule = ""
+		return nil
+	}
+	if _, err := time.ParseDuration(Server.ScanSchedule); err == nil {
+		Server.ScanSchedule = "@every " + Server.ScanSchedule
+	}
+	c := cron.New()
+	_, err := c.AddFunc(Server.ScanSchedule, func() {})
+	if err != nil {
+		log.Error("Invalid ScanSchedule. Please read format spec at https://pkg.go.dev/github.com/robfig/cron#hdr-CRON_Expression_Format", "schedule", Server.ScanSchedule, err)
+	}
+	return err
+}
+
+// AddHook is used to register initialization code that should run as soon as the config is loaded
+func AddHook(hook func()) {
+	hooks = append(hooks, hook)
 }
 
 func init() {
@@ -86,32 +184,63 @@ func init() {
 	viper.SetDefault("address", "0.0.0.0")
 	viper.SetDefault("port", 4533)
 	viper.SetDefault("sessiontimeout", consts.DefaultSessionTimeout)
-	viper.SetDefault("scaninterval", time.Minute)
+	viper.SetDefault("scaninterval", -1)
+	viper.SetDefault("scanschedule", "@every 1m")
 	viper.SetDefault("baseurl", "")
-	viper.SetDefault("uiloginbackgroundurl", "https://source.unsplash.com/random/1600x900?music")
+	viper.SetDefault("uiloginbackgroundurl", consts.DefaultUILoginBackgroundURL)
 	viper.SetDefault("enabletranscodingconfig", false)
 	viper.SetDefault("transcodingcachesize", "100MB")
 	viper.SetDefault("imagecachesize", "100MB")
 	viper.SetDefault("autoimportplaylists", true)
+	viper.SetDefault("playlistspath", consts.DefaultPlaylistsPath)
+	viper.SetDefault("enabledownloads", true)
 
 	// Config options only valid for file/env configuration
 	viper.SetDefault("searchfullstring", false)
+	viper.SetDefault("recentlyaddedbymodtime", false)
 	viper.SetDefault("ignoredarticles", "The El La Los Las Le Les Os As O A")
 	viper.SetDefault("indexgroups", "A B C D E F G H I J K L M N O P Q R S T U V W X-Z(XYZ) [Unknown]([)")
 	viper.SetDefault("probecommand", "ffmpeg %s -f ffmetadata")
 	viper.SetDefault("coverartpriority", "embedded, cover.*, folder.*, front.*")
 	viper.SetDefault("coverjpegquality", 75)
 	viper.SetDefault("uiwelcomemessage", "")
+	viper.SetDefault("enablegravatar", false)
+	viper.SetDefault("enablefavourites", true)
+	viper.SetDefault("enablestarrating", true)
+	viper.SetDefault("enableuserediting", true)
+	viper.SetDefault("defaulttheme", "Dark")
+	viper.SetDefault("enablecoveranimation", true)
 	viper.SetDefault("gatrackingid", "")
+	viper.SetDefault("enablelogredacting", true)
 	viper.SetDefault("authrequestlimit", 5)
 	viper.SetDefault("authwindowlength", 20*time.Second)
+	viper.SetDefault("passwordencryptionkey", "")
 
-	viper.SetDefault("scanner.extractor", "ffmpeg")
+	viper.SetDefault("reverseproxyuserheader", "Remote-User")
+	viper.SetDefault("reverseproxywhitelist", "")
+
+	viper.SetDefault("scanner.extractor", consts.DefaultScannerExtractor)
+	viper.SetDefault("scanner.genreseparators", ";/,")
+
+	viper.SetDefault("agents", "lastfm,spotify")
+	viper.SetDefault("lastfm.enabled", true)
+	viper.SetDefault("lastfm.language", "en")
+	viper.SetDefault("lastfm.apikey", consts.LastFMAPIKey)
+	viper.SetDefault("lastfm.secret", consts.LastFMAPISecret)
+	viper.SetDefault("spotify.id", "")
+	viper.SetDefault("spotify.secret", "")
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
 	viper.SetDefault("devlogsourceline", false)
 	viper.SetDefault("devautocreateadminpassword", "")
-	viper.SetDefault("devoldscanner", false)
+	viper.SetDefault("devautologinusername", "")
+	viper.SetDefault("devprecachealbumartwork", false)
+	viper.SetDefault("devfastaccesscoverart", false)
+	viper.SetDefault("devactivitypanel", true)
+	viper.SetDefault("devenableshare", false)
+	viper.SetDefault("devenablebufferedscrobble", true)
+	viper.SetDefault("devsidebarplaylists", true)
+	viper.SetDefault("devshowartistpage", false)
 }
 
 func InitConfig(cfgFile string) {
@@ -132,8 +261,8 @@ func InitConfig(cfgFile string) {
 	viper.AutomaticEnv()
 
 	err := viper.ReadInConfig()
-	if cfgFile != "" && err != nil {
-		fmt.Println("Navidrome could not open config file: ", err)
+	if viper.ConfigFileUsed() != "" && err != nil {
+		fmt.Println("FATAL: Navidrome could not open config file: ", err)
 		os.Exit(1)
 	}
 }

consts/banner.go

@@ -5,16 +5,15 @@ import (
 	"strings"
 	"unicode"
 
-	"github.com/deluan/navidrome/resources"
+	"github.com/navidrome/navidrome/resources"
 )
 
-func getBanner() string {
+func loadBanner() string {
 	data, _ := resources.Asset("banner.txt")
 	return strings.TrimRightFunc(string(data), unicode.IsSpace)
 }
 
 func Banner() string {
 	version := "Version: " + Version()
-	padding := strings.Repeat(" ", 52-len(version))
-	return fmt.Sprintf("%s\n%s%s\n", getBanner(), padding, version)
+	return fmt.Sprintf("%s\n%52s\n", loadBanner(), version)
 }

consts/consts.go

@@ -3,6 +3,7 @@ package consts
 import (
 	"crypto/md5"
 	"fmt"
+	"path/filepath"
 	"strings"
 	"time"
 )
@@ -13,24 +14,42 @@ const (
 	DefaultDbPath       = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL&_foreign_keys=on"
 	InitialSetupFlagKey = "InitialSetup"
 
-	UIAuthorizationHeader = "X-ND-Authorization"
-	JWTSecretKey          = "JWTSecret"
-	JWTIssuer             = "ND"
-	DefaultSessionTimeout = 24 * time.Hour
+	UIAuthorizationHeader  = "X-ND-Authorization"
+	UIClientUniqueIDHeader = "X-ND-Client-Unique-Id"
+	JWTSecretKey           = "JWTSecret"
+	JWTIssuer              = "ND"
+	DefaultSessionTimeout  = 24 * time.Hour
+	CookieExpiry           = 365 * 24 * 3600 // One year
+
+	// DefaultEncryptionKey This is the encryption key used if none is specified in the `PasswordEncryptionKey` option
+	// Never ever change this! Or it will break all Navidrome installations that don't set the config option
+	DefaultEncryptionKey  = "just for obfuscation"
+	PasswordsEncryptedKey = "PasswordsEncryptedKey"
 
 	DevInitialUserName = "admin"
 	DevInitialName     = "Dev Admin"
 
 	URLPathUI          = "/app"
+	URLPathNativeAPI   = "/api"
 	URLPathSubsonicAPI = "/rest"
 
+	// Login backgrounds from https://unsplash.com/collections/20072696/navidrome
+	DefaultUILoginBackgroundURL = "https://source.unsplash.com/collection/20072696/1600x900"
+
 	RequestThrottleBacklogLimit   = 100
 	RequestThrottleBacklogTimeout = time.Minute
 
+	ArtistInfoTimeToLive = 3 * 24 * time.Hour
+
 	I18nFolder   = "i18n"
 	SkipScanFile = ".ndignore"
 
 	PlaceholderAlbumArt = "navidrome-600x600.png"
+	PlaceholderAvatar   = "logo-192x192.png"
+
+	DefaultHttpClientTimeOut = 10 * time.Second
+
+	DefaultScannerExtractor = "taglib"
 )
 
 // Cache options
@@ -45,6 +64,12 @@ const (
 	DefaultCacheCleanUpInterval = 10 * time.Minute
 )
 
+// Shared secrets (only add here "secrets" that can be public)
+const (
+	LastFMAPIKey    = "9b94a5515ea66b2da3ec03c12300327e"
+	LastFMAPISecret = "74cb6557cec7171d921af5d7d887c587" // nolint:gosec
+)
+
 var (
 	DefaultTranscodings = []map[string]interface{}{
 		{
@@ -60,10 +85,15 @@ var (
 			"command":        "ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -c:a libopus -f opus -",
 		},
 	}
+
+	DefaultPlaylistsPath = strings.Join([]string{".", "**/**"}, string(filepath.ListSeparator))
 )
 
 var (
-	VariousArtists   = "Various Artists"
-	VariousArtistsID = fmt.Sprintf("%x", md5.Sum([]byte(strings.ToLower(VariousArtists))))
-	UnknownArtist    = "[Unknown Artist]"
+	VariousArtists      = "Various Artists"
+	VariousArtistsID    = fmt.Sprintf("%x", md5.Sum([]byte(strings.ToLower(VariousArtists))))
+	UnknownArtist       = "[Unknown Artist]"
+	VariousArtistsMbzId = "89ad4ac3-39f7-470e-963a-56509c546377"
+
+	ServerStart = time.Now()
 )

consts/mime_types.go

@@ -1,36 +1,59 @@
 package consts
 
-import "mime"
+import (
+	"mime"
+	"sort"
+	"strings"
+)
+
+type format struct {
+	typ      string
+	lossless bool
+}
+
+var audioFormats = map[string]format{
+	".mp3":  {typ: "audio/mpeg"},
+	".ogg":  {typ: "audio/ogg"},
+	".oga":  {typ: "audio/ogg"},
+	".opus": {typ: "audio/ogg"},
+	".aac":  {typ: "audio/mp4"},
+	".alac": {typ: "audio/mp4", lossless: true},
+	".m4a":  {typ: "audio/mp4"},
+	".m4b":  {typ: "audio/mp4"},
+	".flac": {typ: "audio/flac", lossless: true},
+	".wav":  {typ: "audio/x-wav", lossless: true},
+	".wma":  {typ: "audio/x-ms-wma"},
+	".ape":  {typ: "audio/x-monkeys-audio", lossless: true},
+	".mpc":  {typ: "audio/x-musepack"},
+	".shn":  {typ: "audio/x-shn", lossless: true},
+	".aif":  {typ: "audio/x-aiff"},
+	".aiff": {typ: "audio/x-aiff"},
+	".m3u":  {typ: "audio/x-mpegurl"},
+	".pls":  {typ: "audio/x-scpls"},
+	".dsf":  {typ: "audio/dsd", lossless: true},
+	".wv":   {typ: "audio/x-wavpack", lossless: true},
+	".wvp":  {typ: "audio/x-wavpack", lossless: true},
+}
+var imageFormats = map[string]string{
+	".gif":  "image/gif",
+	".jpg":  "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".png":  "image/png",
+	".bmp":  "image/bmp",
+}
+
+var LosslessFormats []string
 
 func init() {
-	mt := map[string]string{
-		".mp3":  "audio/mpeg",
-		".ogg":  "audio/ogg",
-		".oga":  "audio/ogg",
-		".opus": "audio/ogg",
-		".aac":  "audio/mp4",
-		".m4a":  "audio/mp4",
-		".m4b":  "audio/mp4",
-		".flac": "audio/flac",
-		".wav":  "audio/x-wav",
-		".wma":  "audio/x-ms-wma",
-		".ape":  "audio/x-monkeys-audio",
-		".mpc":  "audio/x-musepack",
-		".shn":  "audio/x-shn",
-		".aif":  "audio/x-aiff",
-		".aiff": "audio/x-aiff",
-		".m3u":  "audio/x-mpegurl",
-		".pls":  "audio/x-scpls",
-		".dsf":  "audio/dsd",
-		".gif":  "image/gif",
-		".jpg":  "image/jpeg",
-		".jpeg": "image/jpeg",
-		".webp": "image/webp",
-		".png":  "image/png",
-		".bmp":  "image/bmp",
+	for ext, fmt := range audioFormats {
+		_ = mime.AddExtensionType(ext, fmt.typ)
+		if fmt.lossless {
+			LosslessFormats = append(LosslessFormats, strings.TrimPrefix(ext, "."))
+		}
 	}
-
-	for ext, typ := range mt {
+	sort.Strings(LosslessFormats)
+	for ext, typ := range imageFormats {
 		_ = mime.AddExtensionType(ext, typ)
 	}
 }

contrib/freebsd_rc

@@ -0,0 +1,52 @@
+#!/bin/sh
+#
+# $FreeBSD: $
+#
+# PROVIDE: navidrome
+# REQUIRE: NETWORKING
+# KEYWORD:
+#
+# Add the following lines to /etc/rc.conf to enable navidrome:
+# navidrome_enable="YES"
+#
+# navidrome_enable (bool):              Set to YES to enable navidrome
+#                                       Default: NO
+# navidrome_config (str):               navidrome configration file
+#                                       Default: /usr/local/etc/navidrome/config.toml
+# navidrome_datafolder (str):   navidrome Folder to store application data 
+#                                       Default: www
+# navidrome_user (str):         navidrome daemon user
+#                                       Default: www
+# navidrome_group (str):                navidrome daemon group
+#                                       Default: www
+
+. /etc/rc.subr
+
+name="navidrome"
+rcvar="navidrome_enable"
+load_rc_config $name
+
+: ${navidrome_user:="www"}
+: ${navidrome_group:="www"}
+: ${navidrome_enable:="NO"}
+: ${navidrome_config:="/usr/local/etc/navidrome/config.toml"}
+: ${navidrome_flags=""}
+: ${navidrome_facility:="daemon"}
+: ${navidrome_priority:="debug"}
+: ${navidrome_datafolder:="/var/db/${name}"}
+
+required_dirs=${navidrome_datafolder}
+required_files=${navidrome_config}
+procname="/usr/local/bin/${name}"
+pidfile="/var/run/${name}.pid"
+start_precmd="${name}_precmd"
+command=/usr/sbin/daemon
+command_args="-S -l ${navidrome_facility} -s ${navidrome_priority} -T ${name} -t ${name} -p ${pidfile} \
+        ${procname} --configfile ${navidrome_config} --datafolder ${navidrome_datafolder} ${navidrome_flags}"
+
+navidrome_precmd()
+{
+        install -o ${navidrome_user} /dev/null ${pidfile}
+}
+
+run_rc_command "$1"

contrib/navidrome.service

@@ -3,7 +3,6 @@
 [Unit]
 Description=Navidrome Music Server and Streamer compatible with Subsonic/Airsonic
 After=remote-fs.target network.target
-AssertPathExists=/var/lib/navidrome
 
 [Install]
 WantedBy=multi-user.target
@@ -13,6 +12,7 @@ User=navidrome
 Group=navidrome
 Type=simple
 ExecStart=/usr/bin/navidrome
+StateDirectory=navidrome
 WorkingDirectory=/var/lib/navidrome
 TimeoutStopSec=20
 KillMode=process
@@ -21,18 +21,25 @@ Restart=on-failure
 EnvironmentFile=-/etc/sysconfig/navidrome
 
 # See https://www.freedesktop.org/software/systemd/man/systemd.exec.html
+CapabilityBoundingSet=
 DevicePolicy=closed
 NoNewPrivileges=yes
+LockPersonality=yes
 PrivateTmp=yes
 PrivateUsers=yes
 ProtectControlGroups=yes
 ProtectKernelModules=yes
 ProtectKernelTunables=yes
+ProtectClock=yes
+ProtectHostname=yes
+ProtectKernelLogs=yes
 RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
 RestrictNamespaces=yes
 RestrictRealtime=yes
-SystemCallFilter=~@clock @debug @module @mount @obsolete @privileged @reboot @setuid @swap
-ReadWritePaths=/var/lib/navidrome
+SystemCallFilter=@system-service
+SystemCallFilter=~@privileged @resources
+SystemCallArchitectures=native
+UMask=0066
 
 # You can uncomment the following line if you're not using the jukebox This
 # will prevent navidrome from accessing any real (physical) devices

core/agents/README.md

@@ -0,0 +1,12 @@
+This folder abstracts metadata lookup into "agents". Each agent can be implemented to get as
+much info as the external source provides, by using a granular set of interfaces 
+(see [interfaces](interfaces.go)].
+
+A new agent must comply with these simple implementation rules:
+1) Implement the `AgentName()` method. It just returns the name of the agent for logging purposes.
+2) Implement one or more of the `*Retriever()` interfaces. That's where the agent's logic resides.
+3) Register itself  (in its `init()` function).
+
+For an agent to be used it needs to be listed in the `Agents` config option (default is `"lastfm,spotify"`). The order dictates the priority of the agents
+
+For a simple Agent example, look at the [placeholders.go](placeholders.go) agent source code.

core/agents/agents.go

@@ -0,0 +1,161 @@
+package agents
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/model"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/utils"
+)
+
+type Agents struct {
+	ds     model.DataStore
+	agents []Interface
+}
+
+func New(ds model.DataStore) *Agents {
+	order := strings.Split(conf.Server.Agents, ",")
+	order = append(order, PlaceholderAgentName)
+	var res []Interface
+	for _, name := range order {
+		init, ok := Map[name]
+		if !ok {
+			log.Error("Agent not available. Check configuration", "name", name)
+			continue
+		}
+
+		res = append(res, init(ds))
+	}
+
+	return &Agents{ds: ds, agents: res}
+}
+
+func (a *Agents) AgentName() string {
+	return "agents"
+}
+
+func (a *Agents) GetMBID(ctx context.Context, id string, name string) (string, error) {
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistMBIDRetriever)
+		if !ok {
+			continue
+		}
+		mbid, err := agent.GetMBID(ctx, id, name)
+		if mbid != "" && err == nil {
+			log.Debug(ctx, "Got MBID", "agent", ag.AgentName(), "artist", name, "mbid", mbid, "elapsed", time.Since(start))
+			return mbid, err
+		}
+	}
+	return "", ErrNotFound
+}
+
+func (a *Agents) GetURL(ctx context.Context, id, name, mbid string) (string, error) {
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistURLRetriever)
+		if !ok {
+			continue
+		}
+		url, err := agent.GetURL(ctx, id, name, mbid)
+		if url != "" && err == nil {
+			log.Debug(ctx, "Got External Url", "agent", ag.AgentName(), "artist", name, "url", url, "elapsed", time.Since(start))
+			return url, err
+		}
+	}
+	return "", ErrNotFound
+}
+
+func (a *Agents) GetBiography(ctx context.Context, id, name, mbid string) (string, error) {
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistBiographyRetriever)
+		if !ok {
+			continue
+		}
+		bio, err := agent.GetBiography(ctx, id, name, mbid)
+		if bio != "" && err == nil {
+			log.Debug(ctx, "Got Biography", "agent", ag.AgentName(), "artist", name, "len", len(bio), "elapsed", time.Since(start))
+			return bio, err
+		}
+	}
+	return "", ErrNotFound
+}
+
+func (a *Agents) GetSimilar(ctx context.Context, id, name, mbid string, limit int) ([]Artist, error) {
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistSimilarRetriever)
+		if !ok {
+			continue
+		}
+		similar, err := agent.GetSimilar(ctx, id, name, mbid, limit)
+		if len(similar) > 0 && err == nil {
+			log.Debug(ctx, "Got Similar Artists", "agent", ag.AgentName(), "artist", name, "similar", similar, "elapsed", time.Since(start))
+			return similar, err
+		}
+	}
+	return nil, ErrNotFound
+}
+
+func (a *Agents) GetImages(ctx context.Context, id, name, mbid string) ([]ArtistImage, error) {
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistImageRetriever)
+		if !ok {
+			continue
+		}
+		images, err := agent.GetImages(ctx, id, name, mbid)
+		if len(images) > 0 && err == nil {
+			log.Debug(ctx, "Got Images", "agent", ag.AgentName(), "artist", name, "images", images, "elapsed", time.Since(start))
+			return images, err
+		}
+	}
+	return nil, ErrNotFound
+}
+
+func (a *Agents) GetTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error) {
+	start := time.Now()
+	for _, ag := range a.agents {
+		if utils.IsCtxDone(ctx) {
+			break
+		}
+		agent, ok := ag.(ArtistTopSongsRetriever)
+		if !ok {
+			continue
+		}
+		songs, err := agent.GetTopSongs(ctx, id, artistName, mbid, count)
+		if len(songs) > 0 && err == nil {
+			log.Debug(ctx, "Got Top Songs", "agent", ag.AgentName(), "artist", artistName, "songs", songs, "elapsed", time.Since(start))
+			return songs, err
+		}
+	}
+	return nil, ErrNotFound
+}
+
+var _ Interface = (*Agents)(nil)
+var _ ArtistMBIDRetriever = (*Agents)(nil)
+var _ ArtistURLRetriever = (*Agents)(nil)
+var _ ArtistBiographyRetriever = (*Agents)(nil)
+var _ ArtistSimilarRetriever = (*Agents)(nil)
+var _ ArtistImageRetriever = (*Agents)(nil)
+var _ ArtistTopSongsRetriever = (*Agents)(nil)

core/agents/agents_suite_test.go

@@ -0,0 +1,17 @@
+package agents
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestAgents(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Agents Test Suite")
+}

core/agents/agents_test.go

@@ -0,0 +1,249 @@
+package agents
+
+import (
+	"context"
+	"errors"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+
+	"github.com/navidrome/navidrome/conf"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Agents", func() {
+	var ctx context.Context
+	var cancel context.CancelFunc
+	var ds model.DataStore
+	BeforeEach(func() {
+		ctx, cancel = context.WithCancel(context.Background())
+		ds = &tests.MockDataStore{}
+	})
+
+	Describe("Placeholder", func() {
+		var ag *Agents
+		BeforeEach(func() {
+			conf.Server.Agents = ""
+			ag = New(ds)
+		})
+
+		It("calls the placeholder GetBiography", func() {
+			Expect(ag.GetBiography(ctx, "123", "John Doe", "mb123")).To(Equal(placeholderBiography))
+		})
+		It("calls the placeholder GetImages", func() {
+			images, err := ag.GetImages(ctx, "123", "John Doe", "mb123")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(images).To(HaveLen(3))
+			for _, i := range images {
+				Expect(i.URL).To(BeElementOf(placeholderArtistImageSmallUrl, placeholderArtistImageMediumUrl, placeholderArtistImageLargeUrl))
+			}
+		})
+	})
+
+	Describe("Agents", func() {
+		var ag *Agents
+		var mock *mockAgent
+		BeforeEach(func() {
+			mock = &mockAgent{}
+			Register("fake", func(ds model.DataStore) Interface {
+				return mock
+			})
+			Register("empty", func(ds model.DataStore) Interface {
+				return struct {
+					Interface
+				}{}
+			})
+			conf.Server.Agents = "empty,fake"
+			ag = New(ds)
+			Expect(ag.AgentName()).To(Equal("agents"))
+		})
+
+		Describe("GetMBID", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetMBID(ctx, "123", "test")).To(Equal("mbid"))
+				Expect(mock.Args).To(ConsistOf("123", "test"))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetMBID(ctx, "123", "test")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetMBID(ctx, "123", "test")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetURL", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetURL(ctx, "123", "test", "mb123")).To(Equal("url"))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetURL(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetURL(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetBiography", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetBiography(ctx, "123", "test", "mb123")).To(Equal("bio"))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				Expect(ag.GetBiography(ctx, "123", "test", "mb123")).To(Equal(placeholderBiography))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetBiography(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetImages", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetImages(ctx, "123", "test", "mb123")).To(Equal([]ArtistImage{{
+					URL:  "imageUrl",
+					Size: 100,
+				}}))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				Expect(ag.GetImages(ctx, "123", "test", "mb123")).To(HaveLen(3))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123"))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetImages(ctx, "123", "test", "mb123")
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetSimilar", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetSimilar(ctx, "123", "test", "mb123", 1)).To(Equal([]Artist{{
+					Name: "Joe Dohn",
+					MBID: "mbid321",
+				}}))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123", 1))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetSimilar(ctx, "123", "test", "mb123", 1)
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123", 1))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetSimilar(ctx, "123", "test", "mb123", 1)
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+
+		Describe("GetTopSongs", func() {
+			It("returns on first match", func() {
+				Expect(ag.GetTopSongs(ctx, "123", "test", "mb123", 2)).To(Equal([]Song{{
+					Name: "A Song",
+					MBID: "mbid444",
+				}}))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123", 2))
+			})
+			It("skips the agent if it returns an error", func() {
+				mock.Err = errors.New("error")
+				_, err := ag.GetTopSongs(ctx, "123", "test", "mb123", 2)
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(ConsistOf("123", "test", "mb123", 2))
+			})
+			It("interrupts if the context is canceled", func() {
+				cancel()
+				_, err := ag.GetTopSongs(ctx, "123", "test", "mb123", 2)
+				Expect(err).To(MatchError(ErrNotFound))
+				Expect(mock.Args).To(BeEmpty())
+			})
+		})
+	})
+})
+
+type mockAgent struct {
+	Args []interface{}
+	Err  error
+}
+
+func (a *mockAgent) AgentName() string {
+	return "fake"
+}
+
+func (a *mockAgent) GetMBID(ctx context.Context, id string, name string) (string, error) {
+	a.Args = []interface{}{id, name}
+	if a.Err != nil {
+		return "", a.Err
+	}
+	return "mbid", nil
+}
+
+func (a *mockAgent) GetURL(ctx context.Context, id, name, mbid string) (string, error) {
+	a.Args = []interface{}{id, name, mbid}
+	if a.Err != nil {
+		return "", a.Err
+	}
+	return "url", nil
+}
+
+func (a *mockAgent) GetBiography(ctx context.Context, id, name, mbid string) (string, error) {
+	a.Args = []interface{}{id, name, mbid}
+	if a.Err != nil {
+		return "", a.Err
+	}
+	return "bio", nil
+}
+
+func (a *mockAgent) GetImages(ctx context.Context, id, name, mbid string) ([]ArtistImage, error) {
+	a.Args = []interface{}{id, name, mbid}
+	if a.Err != nil {
+		return nil, a.Err
+	}
+	return []ArtistImage{{
+		URL:  "imageUrl",
+		Size: 100,
+	}}, nil
+}
+
+func (a *mockAgent) GetSimilar(ctx context.Context, id, name, mbid string, limit int) ([]Artist, error) {
+	a.Args = []interface{}{id, name, mbid, limit}
+	if a.Err != nil {
+		return nil, a.Err
+	}
+	return []Artist{{
+		Name: "Joe Dohn",
+		MBID: "mbid321",
+	}}, nil
+}
+
+func (a *mockAgent) GetTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error) {
+	a.Args = []interface{}{id, artistName, mbid, count}
+	if a.Err != nil {
+		return nil, a.Err
+	}
+	return []Song{{
+		Name: "A Song",
+		MBID: "mbid444",
+	}}, nil
+}

core/agents/interfaces.go

@@ -0,0 +1,66 @@
+package agents
+
+import (
+	"context"
+	"errors"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+type Constructor func(ds model.DataStore) Interface
+
+type Interface interface {
+	AgentName() string
+}
+
+type Artist struct {
+	Name string
+	MBID string
+}
+
+type ArtistImage struct {
+	URL  string
+	Size int
+}
+
+type Song struct {
+	Name string
+	MBID string
+}
+
+var (
+	ErrNotFound = errors.New("not found")
+)
+
+type ArtistMBIDRetriever interface {
+	GetMBID(ctx context.Context, id string, name string) (string, error)
+}
+
+type ArtistURLRetriever interface {
+	GetURL(ctx context.Context, id, name, mbid string) (string, error)
+}
+
+type ArtistBiographyRetriever interface {
+	GetBiography(ctx context.Context, id, name, mbid string) (string, error)
+}
+
+type ArtistSimilarRetriever interface {
+	GetSimilar(ctx context.Context, id, name, mbid string, limit int) ([]Artist, error)
+}
+
+type ArtistImageRetriever interface {
+	GetImages(ctx context.Context, id, name, mbid string) ([]ArtistImage, error)
+}
+
+type ArtistTopSongsRetriever interface {
+	GetTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]Song, error)
+}
+
+var Map map[string]Constructor
+
+func Register(name string, init Constructor) {
+	if Map == nil {
+		Map = make(map[string]Constructor)
+	}
+	Map[name] = init
+}

core/agents/lastfm/agent.go

@@ -0,0 +1,233 @@
+package lastfm
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+)
+
+const (
+	lastFMAgentName = "lastfm"
+)
+
+type lastfmAgent struct {
+	ds          model.DataStore
+	sessionKeys *sessionKeys
+	apiKey      string
+	secret      string
+	lang        string
+	client      *Client
+}
+
+func lastFMConstructor(ds model.DataStore) *lastfmAgent {
+	l := &lastfmAgent{
+		ds:          ds,
+		lang:        conf.Server.LastFM.Language,
+		apiKey:      conf.Server.LastFM.ApiKey,
+		secret:      conf.Server.LastFM.Secret,
+		sessionKeys: &sessionKeys{ds: ds},
+	}
+	hc := &http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	chc := utils.NewCachedHTTPClient(hc, consts.DefaultHttpClientTimeOut)
+	l.client = NewClient(l.apiKey, l.secret, l.lang, chc)
+	return l
+}
+
+func (l *lastfmAgent) AgentName() string {
+	return lastFMAgentName
+}
+
+func (l *lastfmAgent) GetMBID(ctx context.Context, id string, name string) (string, error) {
+	a, err := l.callArtistGetInfo(ctx, name, "")
+	if err != nil {
+		return "", err
+	}
+	if a.MBID == "" {
+		return "", agents.ErrNotFound
+	}
+	return a.MBID, nil
+}
+
+func (l *lastfmAgent) GetURL(ctx context.Context, id, name, mbid string) (string, error) {
+	a, err := l.callArtistGetInfo(ctx, name, mbid)
+	if err != nil {
+		return "", err
+	}
+	if a.URL == "" {
+		return "", agents.ErrNotFound
+	}
+	return a.URL, nil
+}
+
+func (l *lastfmAgent) GetBiography(ctx context.Context, id, name, mbid string) (string, error) {
+	a, err := l.callArtistGetInfo(ctx, name, mbid)
+	if err != nil {
+		return "", err
+	}
+	if a.Bio.Summary == "" {
+		return "", agents.ErrNotFound
+	}
+	return a.Bio.Summary, nil
+}
+
+func (l *lastfmAgent) GetSimilar(ctx context.Context, id, name, mbid string, limit int) ([]agents.Artist, error) {
+	resp, err := l.callArtistGetSimilar(ctx, name, mbid, limit)
+	if err != nil {
+		return nil, err
+	}
+	if len(resp) == 0 {
+		return nil, agents.ErrNotFound
+	}
+	var res []agents.Artist
+	for _, a := range resp {
+		res = append(res, agents.Artist{
+			Name: a.Name,
+			MBID: a.MBID,
+		})
+	}
+	return res, nil
+}
+
+func (l *lastfmAgent) GetTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]agents.Song, error) {
+	resp, err := l.callArtistGetTopTracks(ctx, artistName, mbid, count)
+	if err != nil {
+		return nil, err
+	}
+	if len(resp) == 0 {
+		return nil, agents.ErrNotFound
+	}
+	var res []agents.Song
+	for _, t := range resp {
+		res = append(res, agents.Song{
+			Name: t.Name,
+			MBID: t.MBID,
+		})
+	}
+	return res, nil
+}
+
+func (l *lastfmAgent) callArtistGetInfo(ctx context.Context, name string, mbid string) (*Artist, error) {
+	a, err := l.client.ArtistGetInfo(ctx, name, mbid)
+	lfErr, isLastFMError := err.(*lastFMError)
+	if mbid != "" && ((err == nil && a.Name == "[unknown]") || (isLastFMError && lfErr.Code == 6)) {
+		log.Warn(ctx, "LastFM/artist.getInfo could not find artist by mbid, trying again", "artist", name, "mbid", mbid)
+		return l.callArtistGetInfo(ctx, name, "")
+	}
+
+	if err != nil {
+		log.Error(ctx, "Error calling LastFM/artist.getInfo", "artist", name, "mbid", mbid, err)
+		return nil, err
+	}
+	return a, nil
+}
+
+func (l *lastfmAgent) callArtistGetSimilar(ctx context.Context, name string, mbid string, limit int) ([]Artist, error) {
+	s, err := l.client.ArtistGetSimilar(ctx, name, mbid, limit)
+	lfErr, isLastFMError := err.(*lastFMError)
+	if mbid != "" && ((err == nil && s.Attr.Artist == "[unknown]") || (isLastFMError && lfErr.Code == 6)) {
+		log.Warn(ctx, "LastFM/artist.getSimilar could not find artist by mbid, trying again", "artist", name, "mbid", mbid)
+		return l.callArtistGetSimilar(ctx, name, "", limit)
+	}
+	if err != nil {
+		log.Error(ctx, "Error calling LastFM/artist.getSimilar", "artist", name, "mbid", mbid, err)
+		return nil, err
+	}
+	return s.Artists, nil
+}
+
+func (l *lastfmAgent) callArtistGetTopTracks(ctx context.Context, artistName, mbid string, count int) ([]Track, error) {
+	t, err := l.client.ArtistGetTopTracks(ctx, artistName, mbid, count)
+	lfErr, isLastFMError := err.(*lastFMError)
+	if mbid != "" && ((err == nil && t.Attr.Artist == "[unknown]") || (isLastFMError && lfErr.Code == 6)) {
+		log.Warn(ctx, "LastFM/artist.getTopTracks could not find artist by mbid, trying again", "artist", artistName, "mbid", mbid)
+		return l.callArtistGetTopTracks(ctx, artistName, "", count)
+	}
+	if err != nil {
+		log.Error(ctx, "Error calling LastFM/artist.getTopTracks", "artist", artistName, "mbid", mbid, err)
+		return nil, err
+	}
+	return t.Track, nil
+}
+
+func (l *lastfmAgent) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
+	sk, err := l.sessionKeys.get(ctx, userId)
+	if err != nil || sk == "" {
+		return scrobbler.ErrNotAuthorized
+	}
+
+	err = l.client.UpdateNowPlaying(ctx, sk, ScrobbleInfo{
+		artist:      track.Artist,
+		track:       track.Title,
+		album:       track.Album,
+		trackNumber: track.TrackNumber,
+		mbid:        track.MbzTrackID,
+		duration:    int(track.Duration),
+		albumArtist: track.AlbumArtist,
+	})
+	if err != nil {
+		log.Warn(ctx, "Last.fm client.updateNowPlaying returned error", "track", track.Title, err)
+		return scrobbler.ErrUnrecoverable
+	}
+	return nil
+}
+
+func (l *lastfmAgent) Scrobble(ctx context.Context, userId string, s scrobbler.Scrobble) error {
+	sk, err := l.sessionKeys.get(ctx, userId)
+	if err != nil || sk == "" {
+		return scrobbler.ErrNotAuthorized
+	}
+
+	if s.Duration <= 30 {
+		log.Debug(ctx, "Skipping Last.fm scrobble for short song", "track", s.Title, "duration", s.Duration)
+		return nil
+	}
+	err = l.client.Scrobble(ctx, sk, ScrobbleInfo{
+		artist:      s.Artist,
+		track:       s.Title,
+		album:       s.Album,
+		trackNumber: s.TrackNumber,
+		mbid:        s.MbzTrackID,
+		duration:    int(s.Duration),
+		albumArtist: s.AlbumArtist,
+		timestamp:   s.TimeStamp,
+	})
+	if err == nil {
+		return nil
+	}
+	lfErr, isLastFMError := err.(*lastFMError)
+	if !isLastFMError {
+		log.Warn(ctx, "Last.fm client.scrobble returned error", "track", s.Title, err)
+		return scrobbler.ErrRetryLater
+	}
+	if lfErr.Code == 11 || lfErr.Code == 16 {
+		return scrobbler.ErrRetryLater
+	}
+	return scrobbler.ErrUnrecoverable
+}
+
+func (l *lastfmAgent) IsAuthorized(ctx context.Context, userId string) bool {
+	sk, err := l.sessionKeys.get(ctx, userId)
+	return err == nil && sk != ""
+}
+
+func init() {
+	conf.AddHook(func() {
+		if conf.Server.LastFM.Enabled {
+			agents.Register(lastFMAgentName, func(ds model.DataStore) agents.Interface {
+				return lastFMConstructor(ds)
+			})
+			scrobbler.Register(lastFMAgentName, func(ds model.DataStore) scrobbler.Scrobbler {
+				return lastFMConstructor(ds)
+			})
+		}
+	})
+}

core/agents/lastfm/agent_test.go

@@ -0,0 +1,353 @@
+package lastfm
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+const (
+	lastfmError3 = `{"error":3,"message":"Invalid Method - No method with that name in this package","links":[]}`
+	lastfmError6 = `{"error":6,"message":"The artist you supplied could not be found","links":[]}`
+)
+
+var _ = Describe("lastfmAgent", func() {
+	var ds model.DataStore
+	var ctx context.Context
+	BeforeEach(func() {
+		ds = &tests.MockDataStore{}
+		ctx = context.Background()
+	})
+	Describe("lastFMConstructor", func() {
+		It("uses configured api key and language", func() {
+			conf.Server.LastFM.ApiKey = "123"
+			conf.Server.LastFM.Secret = "secret"
+			conf.Server.LastFM.Language = "pt"
+			agent := lastFMConstructor(ds)
+			Expect(agent.apiKey).To(Equal("123"))
+			Expect(agent.secret).To(Equal("secret"))
+			Expect(agent.lang).To(Equal("pt"))
+		})
+	})
+
+	Describe("GetBiography", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		BeforeEach(func() {
+			httpClient = &tests.FakeHttpClient{}
+			client := NewClient("API_KEY", "SECRET", "pt", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+		})
+
+		It("returns the biography", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+			Expect(agent.GetBiography(ctx, "123", "U2", "mbid-1234")).To(Equal("U2 é uma das mais importantes bandas de rock de todos os tempos. Formada em 1976 em Dublin, composta por Bono (vocalista  e guitarrista), The Edge (guitarrista, pianista e backing vocal), Adam Clayton (baixista), Larry Mullen, Jr. (baterista e percussionista).\n\nDesde a década de 80, U2 é uma das bandas mais populares no mundo. Seus shows são únicos e um verdadeiro festival de efeitos especiais, além de serem um dos que mais arrecadam anualmente. <a href=\"https://www.last.fm/music/U2\">Read more on Last.fm</a>"))
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call fails", func() {
+			httpClient.Err = errors.New("error")
+			_, err := agent.GetBiography(ctx, "123", "U2", "mbid-1234")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call returns an error", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
+			_, err := agent.GetBiography(ctx, "123", "U2", "mbid-1234")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call returns an error 6 and mbid is empty", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+			_, err := agent.GetBiography(ctx, "123", "U2", "")
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+		})
+
+		Context("MBID non existent in Last.FM", func() {
+			It("calls again when the response is artist == [unknown]", func() {
+				f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.unknown.json")
+				httpClient.Res = http.Response{Body: f, StatusCode: 200}
+				_, _ = agent.GetBiography(ctx, "123", "U2", "mbid-1234")
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+			It("calls again when last.fm returns an error 6", func() {
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+				_, _ = agent.GetBiography(ctx, "123", "U2", "mbid-1234")
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+		})
+	})
+
+	Describe("GetSimilar", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		BeforeEach(func() {
+			httpClient = &tests.FakeHttpClient{}
+			client := NewClient("API_KEY", "SECRET", "pt", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+		})
+
+		It("returns similar artists", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.getsimilar.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+			Expect(agent.GetSimilar(ctx, "123", "U2", "mbid-1234", 2)).To(Equal([]agents.Artist{
+				{Name: "Passengers", MBID: "e110c11f-1c94-4471-a350-c38f46b29389"},
+				{Name: "INXS", MBID: "481bf5f9-2e7c-4c44-b08a-05b32bc7c00d"},
+			}))
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call fails", func() {
+			httpClient.Err = errors.New("error")
+			_, err := agent.GetSimilar(ctx, "123", "U2", "mbid-1234", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call returns an error", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
+			_, err := agent.GetSimilar(ctx, "123", "U2", "mbid-1234", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call returns an error 6 and mbid is empty", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+			_, err := agent.GetSimilar(ctx, "123", "U2", "", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+		})
+
+		Context("MBID non existent in Last.FM", func() {
+			It("calls again when the response is artist == [unknown]", func() {
+				f, _ := os.Open("tests/fixtures/lastfm.artist.getsimilar.unknown.json")
+				httpClient.Res = http.Response{Body: f, StatusCode: 200}
+				_, _ = agent.GetSimilar(ctx, "123", "U2", "mbid-1234", 2)
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+			It("calls again when last.fm returns an error 6", func() {
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+				_, _ = agent.GetSimilar(ctx, "123", "U2", "mbid-1234", 2)
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+		})
+	})
+
+	Describe("GetTopSongs", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		BeforeEach(func() {
+			httpClient = &tests.FakeHttpClient{}
+			client := NewClient("API_KEY", "SECRET", "pt", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+		})
+
+		It("returns top songs", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.gettoptracks.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+			Expect(agent.GetTopSongs(ctx, "123", "U2", "mbid-1234", 2)).To(Equal([]agents.Song{
+				{Name: "Beautiful Day", MBID: "f7f264d0-a89b-4682-9cd7-a4e7c37637af"},
+				{Name: "With or Without You", MBID: "6b9a509f-6907-4a6e-9345-2f12da09ba4b"},
+			}))
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call fails", func() {
+			httpClient.Err = errors.New("error")
+			_, err := agent.GetTopSongs(ctx, "123", "U2", "mbid-1234", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call returns an error", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError3)), StatusCode: 200}
+			_, err := agent.GetTopSongs(ctx, "123", "U2", "mbid-1234", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+			Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+		})
+
+		It("returns an error if Last.FM call returns an error 6 and mbid is empty", func() {
+			httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+			_, err := agent.GetTopSongs(ctx, "123", "U2", "", 2)
+			Expect(err).To(HaveOccurred())
+			Expect(httpClient.RequestCount).To(Equal(1))
+		})
+
+		Context("MBID non existent in Last.FM", func() {
+			It("calls again when the response is artist == [unknown]", func() {
+				f, _ := os.Open("tests/fixtures/lastfm.artist.gettoptracks.unknown.json")
+				httpClient.Res = http.Response{Body: f, StatusCode: 200}
+				_, _ = agent.GetTopSongs(ctx, "123", "U2", "mbid-1234", 2)
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+			It("calls again when last.fm returns an error 6", func() {
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+				_, _ = agent.GetTopSongs(ctx, "123", "U2", "mbid-1234", 2)
+				Expect(httpClient.RequestCount).To(Equal(2))
+				Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+			})
+		})
+	})
+
+	Describe("Scrobbling", func() {
+		var agent *lastfmAgent
+		var httpClient *tests.FakeHttpClient
+		var track *model.MediaFile
+		BeforeEach(func() {
+			_ = ds.UserProps(ctx).Put("user-1", sessionKeyProperty, "SK-1")
+			httpClient = &tests.FakeHttpClient{}
+			client := NewClient("API_KEY", "SECRET", "en", httpClient)
+			agent = lastFMConstructor(ds)
+			agent.client = client
+			track = &model.MediaFile{
+				ID:          "123",
+				Title:       "Track Title",
+				Album:       "Track Album",
+				Artist:      "Track Artist",
+				AlbumArtist: "Track AlbumArtist",
+				TrackNumber: 1,
+				Duration:    180,
+				MbzTrackID:  "mbz-123",
+			}
+		})
+
+		Describe("NowPlaying", func() {
+			It("calls Last.fm with correct params", func() {
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
+
+				err := agent.NowPlaying(ctx, "user-1", track)
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
+				sentParams := httpClient.SavedRequest.URL.Query()
+				Expect(sentParams.Get("method")).To(Equal("track.updateNowPlaying"))
+				Expect(sentParams.Get("sk")).To(Equal("SK-1"))
+				Expect(sentParams.Get("track")).To(Equal(track.Title))
+				Expect(sentParams.Get("album")).To(Equal(track.Album))
+				Expect(sentParams.Get("artist")).To(Equal(track.Artist))
+				Expect(sentParams.Get("albumArtist")).To(Equal(track.AlbumArtist))
+				Expect(sentParams.Get("trackNumber")).To(Equal(strconv.Itoa(track.TrackNumber)))
+				Expect(sentParams.Get("duration")).To(Equal(strconv.FormatFloat(float64(track.Duration), 'G', -1, 32)))
+				Expect(sentParams.Get("mbid")).To(Equal(track.MbzTrackID))
+			})
+
+			It("returns ErrNotAuthorized if user is not linked", func() {
+				err := agent.NowPlaying(ctx, "user-2", track)
+				Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
+			})
+		})
+
+		Describe("Scrobble", func() {
+			It("calls Last.fm with correct params", func() {
+				ts := time.Now()
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: ts})
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodPost))
+				sentParams := httpClient.SavedRequest.URL.Query()
+				Expect(sentParams.Get("method")).To(Equal("track.scrobble"))
+				Expect(sentParams.Get("sk")).To(Equal("SK-1"))
+				Expect(sentParams.Get("track")).To(Equal(track.Title))
+				Expect(sentParams.Get("album")).To(Equal(track.Album))
+				Expect(sentParams.Get("artist")).To(Equal(track.Artist))
+				Expect(sentParams.Get("albumArtist")).To(Equal(track.AlbumArtist))
+				Expect(sentParams.Get("trackNumber")).To(Equal(strconv.Itoa(track.TrackNumber)))
+				Expect(sentParams.Get("duration")).To(Equal(strconv.FormatFloat(float64(track.Duration), 'G', -1, 32)))
+				Expect(sentParams.Get("mbid")).To(Equal(track.MbzTrackID))
+				Expect(sentParams.Get("timestamp")).To(Equal(strconv.FormatInt(ts.Unix(), 10)))
+			})
+
+			It("skips songs with less than 31 seconds", func() {
+				track.Duration = 29
+				httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString("{}")), StatusCode: 200}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+
+				Expect(err).ToNot(HaveOccurred())
+				Expect(httpClient.SavedRequest).To(BeNil())
+			})
+
+			It("returns ErrNotAuthorized if user is not linked", func() {
+				err := agent.Scrobble(ctx, "user-2", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrNotAuthorized))
+			})
+
+			It("returns ErrRetryLater on error 11", func() {
+				httpClient.Res = http.Response{
+					Body:       io.NopCloser(bytes.NewBufferString(`{"error":11,"message":"Service Offline - This service is temporarily offline. Try again later."}`)),
+					StatusCode: 400,
+				}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+			})
+
+			It("returns ErrRetryLater on error 16", func() {
+				httpClient.Res = http.Response{
+					Body:       io.NopCloser(bytes.NewBufferString(`{"error":16,"message":"There was a temporary error processing your request. Please try again"}`)),
+					StatusCode: 400,
+				}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+			})
+
+			It("returns ErrRetryLater on http errors", func() {
+				httpClient.Res = http.Response{
+					Body:       io.NopCloser(bytes.NewBufferString(`internal server error`)),
+					StatusCode: 500,
+				}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrRetryLater))
+			})
+
+			It("returns ErrUnrecoverable on other errors", func() {
+				httpClient.Res = http.Response{
+					Body:       io.NopCloser(bytes.NewBufferString(`{"error":8,"message":"Operation failed - Something else went wrong"}`)),
+					StatusCode: 400,
+				}
+
+				err := agent.Scrobble(ctx, "user-1", scrobbler.Scrobble{MediaFile: *track, TimeStamp: time.Now()})
+				Expect(err).To(MatchError(scrobbler.ErrUnrecoverable))
+			})
+		})
+	})
+
+})

core/agents/lastfm/auth_router.go

@@ -0,0 +1,127 @@
+package lastfm
+
+import (
+	"bytes"
+	"context"
+	_ "embed"
+	"net/http"
+	"time"
+
+	"github.com/deluan/rest"
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/server"
+	"github.com/navidrome/navidrome/utils"
+)
+
+//go:embed token_received.html
+var tokenReceivedPage []byte
+
+type Router struct {
+	http.Handler
+	ds          model.DataStore
+	sessionKeys *sessionKeys
+	client      *Client
+	apiKey      string
+	secret      string
+}
+
+func NewRouter(ds model.DataStore) *Router {
+	r := &Router{
+		ds:          ds,
+		apiKey:      conf.Server.LastFM.ApiKey,
+		secret:      conf.Server.LastFM.Secret,
+		sessionKeys: &sessionKeys{ds: ds},
+	}
+	r.Handler = r.routes()
+	hc := &http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	r.client = NewClient(r.apiKey, r.secret, "en", hc)
+	return r
+}
+
+func (s *Router) routes() http.Handler {
+	r := chi.NewRouter()
+
+	r.Group(func(r chi.Router) {
+		r.Use(server.Authenticator(s.ds))
+		r.Use(server.JWTRefresher)
+
+		r.Get("/link", s.getLinkStatus)
+		r.Delete("/link", s.unlink)
+	})
+
+	r.Get("/link/callback", s.callback)
+
+	return r
+}
+
+func (s *Router) getLinkStatus(w http.ResponseWriter, r *http.Request) {
+	resp := map[string]interface{}{"status": true}
+	u, _ := request.UserFrom(r.Context())
+	key, err := s.sessionKeys.get(r.Context(), u.ID)
+	if err != nil && err != model.ErrNotFound {
+		resp["error"] = err
+		resp["status"] = false
+		_ = rest.RespondWithJSON(w, http.StatusInternalServerError, resp)
+		return
+	}
+	resp["status"] = key != ""
+	_ = rest.RespondWithJSON(w, http.StatusOK, resp)
+}
+
+func (s *Router) unlink(w http.ResponseWriter, r *http.Request) {
+	u, _ := request.UserFrom(r.Context())
+	err := s.sessionKeys.delete(r.Context(), u.ID)
+	if err != nil {
+		_ = rest.RespondWithError(w, http.StatusInternalServerError, err.Error())
+	} else {
+		_ = rest.RespondWithJSON(w, http.StatusOK, map[string]string{})
+	}
+}
+
+func (s *Router) callback(w http.ResponseWriter, r *http.Request) {
+	token := utils.ParamString(r, "token")
+	if token == "" {
+		_ = rest.RespondWithError(w, http.StatusBadRequest, "token not received")
+		return
+	}
+	uid := utils.ParamString(r, "uid")
+	if uid == "" {
+		_ = rest.RespondWithError(w, http.StatusBadRequest, "uid not received")
+		return
+	}
+
+	// Need to add user to context, as this is a non-authenticated endpoint, so it does not
+	// automatically contain any user info
+	ctx := request.WithUser(r.Context(), model.User{ID: uid})
+	err := s.fetchSessionKey(ctx, uid, token)
+	if err != nil {
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		w.WriteHeader(http.StatusBadRequest)
+		_, _ = w.Write([]byte("An error occurred while authorizing with Last.fm. \n\nRequest ID: " + middleware.GetReqID(ctx)))
+		return
+	}
+
+	http.ServeContent(w, r, "response", time.Now(), bytes.NewReader(tokenReceivedPage))
+}
+
+func (s *Router) fetchSessionKey(ctx context.Context, uid, token string) error {
+	sessionKey, err := s.client.GetSession(ctx, token)
+	if err != nil {
+		log.Error(ctx, "Could not fetch LastFM session key", "userId", uid, "token", token,
+			"requestId", middleware.GetReqID(ctx), err)
+		return err
+	}
+	err = s.sessionKeys.put(ctx, uid, sessionKey)
+	if err != nil {
+		log.Error("Could not save LastFM session key", "userId", uid, "requestId", middleware.GetReqID(ctx), err)
+	}
+	return err
+}

core/agents/lastfm/client.go

@@ -0,0 +1,221 @@
+package lastfm
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/utils"
+)
+
+const (
+	apiBaseUrl = "https://ws.audioscrobbler.com/2.0/"
+)
+
+type lastFMError struct {
+	Code    int
+	Message string
+}
+
+func (e *lastFMError) Error() string {
+	return fmt.Sprintf("last.fm error(%d): %s", e.Code, e.Message)
+}
+
+type httpDoer interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+func NewClient(apiKey string, secret string, lang string, hc httpDoer) *Client {
+	return &Client{apiKey, secret, lang, hc}
+}
+
+type Client struct {
+	apiKey string
+	secret string
+	lang   string
+	hc     httpDoer
+}
+
+func (c *Client) ArtistGetInfo(ctx context.Context, name string, mbid string) (*Artist, error) {
+	params := url.Values{}
+	params.Add("method", "artist.getInfo")
+	params.Add("artist", name)
+	params.Add("mbid", mbid)
+	params.Add("lang", c.lang)
+	response, err := c.makeRequest(http.MethodGet, params, false)
+	if err != nil {
+		return nil, err
+	}
+	return &response.Artist, nil
+}
+
+func (c *Client) ArtistGetSimilar(ctx context.Context, name string, mbid string, limit int) (*SimilarArtists, error) {
+	params := url.Values{}
+	params.Add("method", "artist.getSimilar")
+	params.Add("artist", name)
+	params.Add("mbid", mbid)
+	params.Add("limit", strconv.Itoa(limit))
+	response, err := c.makeRequest(http.MethodGet, params, false)
+	if err != nil {
+		return nil, err
+	}
+	return &response.SimilarArtists, nil
+}
+
+func (c *Client) ArtistGetTopTracks(ctx context.Context, name string, mbid string, limit int) (*TopTracks, error) {
+	params := url.Values{}
+	params.Add("method", "artist.getTopTracks")
+	params.Add("artist", name)
+	params.Add("mbid", mbid)
+	params.Add("limit", strconv.Itoa(limit))
+	response, err := c.makeRequest(http.MethodGet, params, false)
+	if err != nil {
+		return nil, err
+	}
+	return &response.TopTracks, nil
+}
+
+func (c *Client) GetToken(ctx context.Context) (string, error) {
+	params := url.Values{}
+	params.Add("method", "auth.getToken")
+	c.sign(params)
+	response, err := c.makeRequest(http.MethodGet, params, true)
+	if err != nil {
+		return "", err
+	}
+	return response.Token, nil
+}
+
+func (c *Client) GetSession(ctx context.Context, token string) (string, error) {
+	params := url.Values{}
+	params.Add("method", "auth.getSession")
+	params.Add("token", token)
+	response, err := c.makeRequest(http.MethodGet, params, true)
+	if err != nil {
+		return "", err
+	}
+	return response.Session.Key, nil
+}
+
+type ScrobbleInfo struct {
+	artist      string
+	track       string
+	album       string
+	trackNumber int
+	mbid        string
+	duration    int
+	albumArtist string
+	timestamp   time.Time
+}
+
+func (c *Client) UpdateNowPlaying(ctx context.Context, sessionKey string, info ScrobbleInfo) error {
+	params := url.Values{}
+	params.Add("method", "track.updateNowPlaying")
+	params.Add("artist", info.artist)
+	params.Add("track", info.track)
+	params.Add("album", info.album)
+	params.Add("trackNumber", strconv.Itoa(info.trackNumber))
+	params.Add("mbid", info.mbid)
+	params.Add("duration", strconv.Itoa(info.duration))
+	params.Add("albumArtist", info.albumArtist)
+	params.Add("sk", sessionKey)
+	resp, err := c.makeRequest(http.MethodPost, params, true)
+	if err != nil {
+		return err
+	}
+	if resp.NowPlaying.IgnoredMessage.Code != "0" {
+		log.Warn(ctx, "LastFM: NowPlaying was ignored", "code", resp.NowPlaying.IgnoredMessage.Code,
+			"text", resp.NowPlaying.IgnoredMessage.Text)
+	}
+	return nil
+}
+
+func (c *Client) Scrobble(ctx context.Context, sessionKey string, info ScrobbleInfo) error {
+	params := url.Values{}
+	params.Add("method", "track.scrobble")
+	params.Add("timestamp", strconv.FormatInt(info.timestamp.Unix(), 10))
+	params.Add("artist", info.artist)
+	params.Add("track", info.track)
+	params.Add("album", info.album)
+	params.Add("trackNumber", strconv.Itoa(info.trackNumber))
+	params.Add("mbid", info.mbid)
+	params.Add("duration", strconv.Itoa(info.duration))
+	params.Add("albumArtist", info.albumArtist)
+	params.Add("sk", sessionKey)
+	resp, err := c.makeRequest(http.MethodPost, params, true)
+	if err != nil {
+		return err
+	}
+	if resp.Scrobbles.Scrobble.IgnoredMessage.Code != "0" {
+		log.Warn(ctx, "LastFM: Scrobble was ignored", "code", resp.Scrobbles.Scrobble.IgnoredMessage.Code,
+			"text", resp.Scrobbles.Scrobble.IgnoredMessage.Text)
+	}
+	if resp.Scrobbles.Attr.Accepted != 1 {
+		log.Warn(ctx, "LastFM: Scrobble was not accepted", "code", resp.Scrobbles.Scrobble.IgnoredMessage.Code,
+			"text", resp.Scrobbles.Scrobble.IgnoredMessage.Text)
+	}
+	return nil
+}
+
+func (c *Client) makeRequest(method string, params url.Values, signed bool) (*Response, error) {
+	params.Add("format", "json")
+	params.Add("api_key", c.apiKey)
+
+	if signed {
+		c.sign(params)
+	}
+
+	req, _ := http.NewRequest(method, apiBaseUrl, nil)
+	req.URL.RawQuery = params.Encode()
+
+	resp, err := c.hc.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	defer resp.Body.Close()
+	decoder := json.NewDecoder(resp.Body)
+
+	var response Response
+	jsonErr := decoder.Decode(&response)
+	if resp.StatusCode != 200 && jsonErr != nil {
+		return nil, fmt.Errorf("last.fm http status: (%d)", resp.StatusCode)
+	}
+	if jsonErr != nil {
+		return nil, jsonErr
+	}
+	if response.Error != 0 {
+		return &response, &lastFMError{Code: response.Error, Message: response.Message}
+	}
+
+	return &response, nil
+}
+
+func (c *Client) sign(params url.Values) {
+	// the parameters must be in order before hashing
+	keys := make([]string, 0, len(params))
+	for k := range params {
+		if utils.StringInSlice(k, []string{"format", "callback"}) {
+			continue
+		}
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	msg := strings.Builder{}
+	for _, k := range keys {
+		msg.WriteString(k)
+		msg.WriteString(params[k][0])
+	}
+	msg.WriteString(c.secret)
+	hash := md5.Sum([]byte(msg.String()))
+	params.Add("api_sig", hex.EncodeToString(hash[:]))
+}

core/agents/lastfm/client_test.go

@@ -0,0 +1,161 @@
+package lastfm
+
+import (
+	"bytes"
+	"context"
+	"crypto/md5"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Client", func() {
+	var httpClient *tests.FakeHttpClient
+	var client *Client
+
+	BeforeEach(func() {
+		httpClient = &tests.FakeHttpClient{}
+		client = NewClient("API_KEY", "SECRET", "pt", httpClient)
+	})
+
+	Describe("ArtistGetInfo", func() {
+		It("returns an artist for a successful response", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+
+			artist, err := client.ArtistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(BeNil())
+			Expect(artist.Name).To(Equal("U2"))
+			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&lang=pt&mbid=123&method=artist.getInfo"))
+		})
+
+		It("fails if Last.FM returns an http status != 200", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`Internal Server Error`)),
+				StatusCode: 500,
+			}
+
+			_, err := client.ArtistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError("last.fm http status: (500)"))
+		})
+
+		It("fails if Last.FM returns an http status != 200", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":3,"message":"Invalid Method - No method with that name in this package"}`)),
+				StatusCode: 400,
+			}
+
+			_, err := client.ArtistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError(&lastFMError{Code: 3, Message: "Invalid Method - No method with that name in this package"}))
+		})
+
+		It("fails if Last.FM returns an error", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":6,"message":"The artist you supplied could not be found"}`)),
+				StatusCode: 200,
+			}
+
+			_, err := client.ArtistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError(&lastFMError{Code: 6, Message: "The artist you supplied could not be found"}))
+		})
+
+		It("fails if HttpClient.Do() returns error", func() {
+			httpClient.Err = errors.New("generic error")
+
+			_, err := client.ArtistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError("generic error"))
+		})
+
+		It("fails if returned body is not a valid JSON", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`<xml>NOT_VALID_JSON</xml>`)),
+				StatusCode: 200,
+			}
+
+			_, err := client.ArtistGetInfo(context.Background(), "U2", "123")
+			Expect(err).To(MatchError("invalid character '<' looking for beginning of value"))
+		})
+
+	})
+
+	Describe("ArtistGetSimilar", func() {
+		It("returns an artist for a successful response", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.getsimilar.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+
+			similar, err := client.ArtistGetSimilar(context.Background(), "U2", "123", 2)
+			Expect(err).To(BeNil())
+			Expect(len(similar.Artists)).To(Equal(2))
+			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&limit=2&mbid=123&method=artist.getSimilar"))
+		})
+	})
+
+	Describe("ArtistGetTopTracks", func() {
+		It("returns top tracks for a successful response", func() {
+			f, _ := os.Open("tests/fixtures/lastfm.artist.gettoptracks.json")
+			httpClient.Res = http.Response{Body: f, StatusCode: 200}
+
+			top, err := client.ArtistGetTopTracks(context.Background(), "U2", "123", 2)
+			Expect(err).To(BeNil())
+			Expect(len(top.Track)).To(Equal(2))
+			Expect(httpClient.SavedRequest.URL.String()).To(Equal(apiBaseUrl + "?api_key=API_KEY&artist=U2&format=json&limit=2&mbid=123&method=artist.getTopTracks"))
+		})
+	})
+
+	Describe("GetToken", func() {
+		It("returns a token when the request is successful", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"token":"TOKEN"}`)),
+				StatusCode: 200,
+			}
+
+			Expect(client.GetToken(context.Background())).To(Equal("TOKEN"))
+			queryParams := httpClient.SavedRequest.URL.Query()
+			Expect(queryParams.Get("method")).To(Equal("auth.getToken"))
+			Expect(queryParams.Get("format")).To(Equal("json"))
+			Expect(queryParams.Get("api_key")).To(Equal("API_KEY"))
+			Expect(queryParams.Get("api_sig")).ToNot(BeEmpty())
+		})
+	})
+
+	Describe("GetSession", func() {
+		It("returns a session key when the request is successful", func() {
+			httpClient.Res = http.Response{
+				Body:       io.NopCloser(bytes.NewBufferString(`{"session":{"name":"Navidrome","key":"SESSION_KEY","subscriber":0}}`)),
+				StatusCode: 200,
+			}
+
+			Expect(client.GetSession(context.Background(), "TOKEN")).To(Equal("SESSION_KEY"))
+			queryParams := httpClient.SavedRequest.URL.Query()
+			Expect(queryParams.Get("method")).To(Equal("auth.getSession"))
+			Expect(queryParams.Get("format")).To(Equal("json"))
+			Expect(queryParams.Get("token")).To(Equal("TOKEN"))
+			Expect(queryParams.Get("api_key")).To(Equal("API_KEY"))
+			Expect(queryParams.Get("api_sig")).ToNot(BeEmpty())
+		})
+	})
+
+	Describe("sign", func() {
+		It("adds an api_sig param with the signature", func() {
+			params := url.Values{}
+			params.Add("d", "444")
+			params.Add("callback", "https://myserver.com")
+			params.Add("a", "111")
+			params.Add("format", "json")
+			params.Add("c", "333")
+			params.Add("b", "222")
+			client.sign(params)
+			Expect(params).To(HaveKey("api_sig"))
+			sig := params.Get("api_sig")
+			expected := fmt.Sprintf("%x", md5.Sum([]byte("a111b222c333d444SECRET")))
+			Expect(sig).To(Equal(expected))
+		})
+	})
+})

core/agents/lastfm/lastfm_suite_test.go

@@ -0,0 +1,17 @@
+package lastfm
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestLastFM(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "LastFM Test Suite")
+}

core/agents/lastfm/responses.go

@@ -0,0 +1,110 @@
+package lastfm
+
+type Response struct {
+	Artist         Artist         `json:"artist"`
+	SimilarArtists SimilarArtists `json:"similarartists"`
+	TopTracks      TopTracks      `json:"toptracks"`
+	Error          int            `json:"error"`
+	Message        string         `json:"message"`
+	Token          string         `json:"token"`
+	Session        Session        `json:"session"`
+	NowPlaying     NowPlaying     `json:"nowplaying"`
+	Scrobbles      Scrobbles      `json:"scrobbles"`
+}
+
+type Artist struct {
+	Name  string        `json:"name"`
+	MBID  string        `json:"mbid"`
+	URL   string        `json:"url"`
+	Image []ArtistImage `json:"image"`
+	Bio   ArtistBio     `json:"bio"`
+}
+
+type SimilarArtists struct {
+	Artists []Artist `json:"artist"`
+	Attr    Attr     `json:"@attr"`
+}
+
+type Attr struct {
+	Artist string `json:"artist"`
+}
+
+type ArtistImage struct {
+	URL  string `json:"#text"`
+	Size string `json:"size"`
+}
+
+type ArtistBio struct {
+	Published string `json:"published"`
+	Summary   string `json:"summary"`
+	Content   string `json:"content"`
+}
+
+type Track struct {
+	Name string `json:"name"`
+	MBID string `json:"mbid"`
+}
+
+type TopTracks struct {
+	Track []Track `json:"track"`
+	Attr  Attr    `json:"@attr"`
+}
+
+type Session struct {
+	Name       string `json:"name"`
+	Key        string `json:"key"`
+	Subscriber int    `json:"subscriber"`
+}
+
+type NowPlaying struct {
+	Artist struct {
+		Corrected string `json:"corrected"`
+		Text      string `json:"#text"`
+	} `json:"artist"`
+	IgnoredMessage struct {
+		Code string `json:"code"`
+		Text string `json:"#text"`
+	} `json:"ignoredMessage"`
+	Album struct {
+		Corrected string `json:"corrected"`
+		Text      string `json:"#text"`
+	} `json:"album"`
+	AlbumArtist struct {
+		Corrected string `json:"corrected"`
+		Text      string `json:"#text"`
+	} `json:"albumArtist"`
+	Track struct {
+		Corrected string `json:"corrected"`
+		Text      string `json:"#text"`
+	} `json:"track"`
+}
+
+type Scrobbles struct {
+	Attr struct {
+		Accepted int `json:"accepted"`
+		Ignored  int `json:"ignored"`
+	} `json:"@attr"`
+	Scrobble struct {
+		Artist struct {
+			Corrected string `json:"corrected"`
+			Text      string `json:"#text"`
+		} `json:"artist"`
+		IgnoredMessage struct {
+			Code string `json:"code"`
+			Text string `json:"#text"`
+		} `json:"ignoredMessage"`
+		AlbumArtist struct {
+			Corrected string `json:"corrected"`
+			Text      string `json:"#text"`
+		} `json:"albumArtist"`
+		Timestamp string `json:"timestamp"`
+		Album     struct {
+			Corrected string `json:"corrected"`
+			Text      string `json:"#text"`
+		} `json:"album"`
+		Track struct {
+			Corrected string `json:"corrected"`
+			Text      string `json:"#text"`
+		} `json:"track"`
+	} `json:"scrobble"`
+}

core/agents/lastfm/responses_test.go

@@ -0,0 +1,65 @@
+package lastfm
+
+import (
+	"encoding/json"
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("LastFM responses", func() {
+	Describe("Artist", func() {
+		It("parses the response correctly", func() {
+			var resp Response
+			body, _ := os.ReadFile("tests/fixtures/lastfm.artist.getinfo.json")
+			err := json.Unmarshal(body, &resp)
+			Expect(err).To(BeNil())
+
+			Expect(resp.Artist.Name).To(Equal("U2"))
+			Expect(resp.Artist.MBID).To(Equal("a3cb23fc-acd3-4ce0-8f36-1e5aa6a18432"))
+			Expect(resp.Artist.URL).To(Equal("https://www.last.fm/music/U2"))
+			Expect(resp.Artist.Bio.Summary).To(ContainSubstring("U2 é uma das mais importantes bandas de rock de todos os tempos"))
+		})
+	})
+
+	Describe("SimilarArtists", func() {
+		It("parses the response correctly", func() {
+			var resp Response
+			body, _ := os.ReadFile("tests/fixtures/lastfm.artist.getsimilar.json")
+			err := json.Unmarshal(body, &resp)
+			Expect(err).To(BeNil())
+
+			Expect(resp.SimilarArtists.Artists).To(HaveLen(2))
+			Expect(resp.SimilarArtists.Artists[0].Name).To(Equal("Passengers"))
+			Expect(resp.SimilarArtists.Artists[1].Name).To(Equal("INXS"))
+		})
+	})
+
+	Describe("TopTracks", func() {
+		It("parses the response correctly", func() {
+			var resp Response
+			body, _ := os.ReadFile("tests/fixtures/lastfm.artist.gettoptracks.json")
+			err := json.Unmarshal(body, &resp)
+			Expect(err).To(BeNil())
+
+			Expect(resp.TopTracks.Track).To(HaveLen(2))
+			Expect(resp.TopTracks.Track[0].Name).To(Equal("Beautiful Day"))
+			Expect(resp.TopTracks.Track[0].MBID).To(Equal("f7f264d0-a89b-4682-9cd7-a4e7c37637af"))
+			Expect(resp.TopTracks.Track[1].Name).To(Equal("With or Without You"))
+			Expect(resp.TopTracks.Track[1].MBID).To(Equal("6b9a509f-6907-4a6e-9345-2f12da09ba4b"))
+		})
+	})
+
+	Describe("Error", func() {
+		It("parses the error response correctly", func() {
+			var error Response
+			body := []byte(`{"error":3,"message":"Invalid Method - No method with that name in this package"}`)
+			err := json.Unmarshal(body, &error)
+			Expect(err).To(BeNil())
+
+			Expect(error.Error).To(Equal(3))
+			Expect(error.Message).To(Equal("Invalid Method - No method with that name in this package"))
+		})
+	})
+})

core/agents/lastfm/session_keys.go

@@ -0,0 +1,28 @@
+package lastfm
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+const (
+	sessionKeyProperty = "LastFMSessionKey"
+)
+
+// sessionKeys is a simple wrapper around the UserPropsRepository
+type sessionKeys struct {
+	ds model.DataStore
+}
+
+func (sk *sessionKeys) put(ctx context.Context, userId, sessionKey string) error {
+	return sk.ds.UserProps(ctx).Put(userId, sessionKeyProperty, sessionKey)
+}
+
+func (sk *sessionKeys) get(ctx context.Context, userId string) (string, error) {
+	return sk.ds.UserProps(ctx).Get(userId, sessionKeyProperty)
+}
+
+func (sk *sessionKeys) delete(ctx context.Context, userId string) error {
+	return sk.ds.UserProps(ctx).Delete(userId, sessionKeyProperty)
+}

core/agents/lastfm/token_received.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Account Linking Success</title>
+  </head>
+  <body>
+    <h2 id="msg"></h2>
+    <script>
+      setTimeout("document.getElementById('msg').innerHTML = 'Success! Your account is linked to Last.fm. You can close this tab now.';",2000)
+      document.addEventListener("DOMContentLoaded", () => {
+        window.close();
+      });
+    </script>
+  </body>
+</html>

core/agents/placeholders.go

@@ -0,0 +1,42 @@
+package agents
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+const PlaceholderAgentName = "placeholder"
+
+const (
+	placeholderArtistImageSmallUrl  = "https://lastfm.freetls.fastly.net/i/u/64s/2a96cbd8b46e442fc41c2b86b821562f.png"
+	placeholderArtistImageMediumUrl = "https://lastfm.freetls.fastly.net/i/u/174s/2a96cbd8b46e442fc41c2b86b821562f.png"
+	placeholderArtistImageLargeUrl  = "https://lastfm.freetls.fastly.net/i/u/300x300/2a96cbd8b46e442fc41c2b86b821562f.png"
+	placeholderBiography            = "Biography not available"
+)
+
+type placeholderAgent struct{}
+
+func placeholdersConstructor(ds model.DataStore) Interface {
+	return &placeholderAgent{}
+}
+
+func (p *placeholderAgent) AgentName() string {
+	return PlaceholderAgentName
+}
+
+func (p *placeholderAgent) GetBiography(ctx context.Context, id, name, mbid string) (string, error) {
+	return placeholderBiography, nil
+}
+
+func (p *placeholderAgent) GetImages(ctx context.Context, id, name, mbid string) ([]ArtistImage, error) {
+	return []ArtistImage{
+		{placeholderArtistImageLargeUrl, 300},
+		{placeholderArtistImageMediumUrl, 174},
+		{placeholderArtistImageSmallUrl, 64},
+	}, nil
+}
+
+func init() {
+	Register(PlaceholderAgentName, placeholdersConstructor)
+}

core/agents/spotify/client.go

@@ -0,0 +1,115 @@
+package spotify
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"github.com/navidrome/navidrome/log"
+)
+
+const apiBaseUrl = "https://api.spotify.com/v1/"
+
+var (
+	ErrNotFound = errors.New("spotify: not found")
+)
+
+type httpDoer interface {
+	Do(req *http.Request) (*http.Response, error)
+}
+
+func NewClient(id, secret string, hc httpDoer) *Client {
+	return &Client{id, secret, hc}
+}
+
+type Client struct {
+	id     string
+	secret string
+	hc     httpDoer
+}
+
+func (c *Client) SearchArtists(ctx context.Context, name string, limit int) ([]Artist, error) {
+	token, err := c.authorize(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	params := url.Values{}
+	params.Add("type", "artist")
+	params.Add("q", name)
+	params.Add("offset", "0")
+	params.Add("limit", strconv.Itoa(limit))
+	req, _ := http.NewRequest("GET", apiBaseUrl+"search", nil)
+	req.URL.RawQuery = params.Encode()
+	req.Header.Add("Authorization", "Bearer "+token)
+
+	var results SearchResults
+	err = c.makeRequest(req, &results)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(results.Artists.Items) == 0 {
+		return nil, ErrNotFound
+	}
+	return results.Artists.Items, err
+}
+
+func (c *Client) authorize(ctx context.Context) (string, error) {
+	payload := url.Values{}
+	payload.Add("grant_type", "client_credentials")
+
+	encodePayload := payload.Encode()
+	req, _ := http.NewRequest("POST", "https://accounts.spotify.com/api/token", strings.NewReader(encodePayload))
+	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	req.Header.Add("Content-Length", strconv.Itoa(len(encodePayload)))
+	auth := c.id + ":" + c.secret
+	req.Header.Add("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte(auth)))
+
+	response := map[string]interface{}{}
+	err := c.makeRequest(req, &response)
+	if err != nil {
+		return "", err
+	}
+
+	if v, ok := response["access_token"]; ok {
+		return v.(string), nil
+	}
+	log.Error(ctx, "Invalid spotify response", "resp", response)
+	return "", errors.New("invalid response")
+}
+
+func (c *Client) makeRequest(req *http.Request, response interface{}) error {
+	resp, err := c.hc.Do(req)
+	if err != nil {
+		return err
+	}
+
+	defer resp.Body.Close()
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != 200 {
+		return c.parseError(data)
+	}
+
+	return json.Unmarshal(data, response)
+}
+
+func (c *Client) parseError(data []byte) error {
+	var e Error
+	err := json.Unmarshal(data, &e)
+	if err != nil {
+		return err
+	}
+	return fmt.Errorf("spotify error(%s): %s", e.Code, e.Message)
+}

core/agents/spotify/client_test.go

@@ -0,0 +1,131 @@
+package spotify
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"net/http"
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Client", func() {
+	var httpClient *fakeHttpClient
+	var client *Client
+
+	BeforeEach(func() {
+		httpClient = &fakeHttpClient{}
+		client = NewClient("SPOTIFY_ID", "SPOTIFY_SECRET", httpClient)
+	})
+
+	Describe("ArtistImages", func() {
+		It("returns artist images from a successful request", func() {
+			f, _ := os.Open("tests/fixtures/spotify.search.artist.json")
+			httpClient.mock("https://api.spotify.com/v1/search", http.Response{Body: f, StatusCode: 200})
+			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
+				StatusCode: 200,
+				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
+			})
+
+			artists, err := client.SearchArtists(context.TODO(), "U2", 10)
+			Expect(err).To(BeNil())
+			Expect(artists).To(HaveLen(20))
+			Expect(artists[0].Popularity).To(Equal(82))
+
+			images := artists[0].Images
+			Expect(images).To(HaveLen(3))
+			Expect(images[0].Width).To(Equal(640))
+			Expect(images[1].Width).To(Equal(320))
+			Expect(images[2].Width).To(Equal(160))
+		})
+
+		It("fails if artist was not found", func() {
+			httpClient.mock("https://api.spotify.com/v1/search", http.Response{
+				StatusCode: 200,
+				Body: io.NopCloser(bytes.NewBufferString(`{
+						  "artists" : {
+							"href" : "https://api.spotify.com/v1/search?query=dasdasdas%2Cdna&type=artist&offset=0&limit=20",
+							"items" : [ ], "limit" : 20, "next" : null, "offset" : 0, "previous" : null, "total" : 0
+						  }}`)),
+			})
+			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
+				StatusCode: 200,
+				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
+			})
+
+			_, err := client.SearchArtists(context.TODO(), "U2", 10)
+			Expect(err).To(MatchError(ErrNotFound))
+		})
+
+		It("fails if not able to authorize", func() {
+			f, _ := os.Open("tests/fixtures/spotify.search.artist.json")
+			httpClient.mock("https://api.spotify.com/v1/search", http.Response{Body: f, StatusCode: 200})
+			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
+				StatusCode: 400,
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":"invalid_client","error_description":"Invalid client"}`)),
+			})
+
+			_, err := client.SearchArtists(context.TODO(), "U2", 10)
+			Expect(err).To(MatchError("spotify error(invalid_client): Invalid client"))
+		})
+	})
+
+	Describe("authorize", func() {
+		It("returns an access_token on successful authorization", func() {
+			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
+				StatusCode: 200,
+				Body:       io.NopCloser(bytes.NewBufferString(`{"access_token": "NEW_ACCESS_TOKEN","token_type": "Bearer","expires_in": 3600}`)),
+			})
+
+			token, err := client.authorize(context.TODO())
+			Expect(err).To(BeNil())
+			Expect(token).To(Equal("NEW_ACCESS_TOKEN"))
+			auth := httpClient.lastRequest.Header.Get("Authorization")
+			Expect(auth).To(Equal("Basic U1BPVElGWV9JRDpTUE9USUZZX1NFQ1JFVA=="))
+		})
+
+		It("fails on unsuccessful authorization", func() {
+			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
+				StatusCode: 400,
+				Body:       io.NopCloser(bytes.NewBufferString(`{"error":"invalid_client","error_description":"Invalid client"}`)),
+			})
+
+			_, err := client.authorize(context.TODO())
+			Expect(err).To(MatchError("spotify error(invalid_client): Invalid client"))
+		})
+
+		It("fails on invalid JSON response", func() {
+			httpClient.mock("https://accounts.spotify.com/api/token", http.Response{
+				StatusCode: 200,
+				Body:       io.NopCloser(bytes.NewBufferString(`{NOT_VALID}`)),
+			})
+
+			_, err := client.authorize(context.TODO())
+			Expect(err).To(MatchError("invalid character 'N' looking for beginning of object key string"))
+		})
+	})
+})
+
+type fakeHttpClient struct {
+	responses   map[string]*http.Response
+	lastRequest *http.Request
+}
+
+func (c *fakeHttpClient) mock(url string, response http.Response) {
+	if c.responses == nil {
+		c.responses = make(map[string]*http.Response)
+	}
+	c.responses[url] = &response
+}
+
+func (c *fakeHttpClient) Do(req *http.Request) (*http.Response, error) {
+	c.lastRequest = req
+	u := req.URL
+	u.RawQuery = ""
+	if resp, ok := c.responses[u.String()]; ok {
+		return resp, nil
+	}
+	panic("URL not mocked: " + u.String())
+}

core/agents/spotify/responses.go

@@ -0,0 +1,30 @@
+package spotify
+
+type SearchResults struct {
+	Artists ArtistsResult `json:"artists"`
+}
+
+type ArtistsResult struct {
+	HRef  string   `json:"href"`
+	Items []Artist `json:"items"`
+}
+
+type Artist struct {
+	Genres     []string `json:"genres"`
+	HRef       string   `json:"href"`
+	ID         string   `json:"id"`
+	Popularity int      `json:"popularity"`
+	Images     []Image  `json:"images"`
+	Name       string   `json:"name"`
+}
+
+type Image struct {
+	URL    string `json:"url"`
+	Width  int    `json:"width"`
+	Height int    `json:"height"`
+}
+
+type Error struct {
+	Code    string `json:"error"`
+	Message string `json:"error_description"`
+}

core/agents/spotify/responses_test.go

@@ -0,0 +1,48 @@
+package spotify
+
+import (
+	"encoding/json"
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Responses", func() {
+	Describe("Search type=artist", func() {
+		It("parses the artist search result correctly ", func() {
+			var resp SearchResults
+			body, _ := os.ReadFile("tests/fixtures/spotify.search.artist.json")
+			err := json.Unmarshal(body, &resp)
+			Expect(err).To(BeNil())
+
+			Expect(resp.Artists.Items).To(HaveLen(20))
+			u2 := resp.Artists.Items[0]
+			Expect(u2.Name).To(Equal("U2"))
+			Expect(u2.Genres).To(ContainElements("irish rock", "permanent wave", "rock"))
+			Expect(u2.ID).To(Equal("51Blml2LZPmy7TTiAg47vQ"))
+			Expect(u2.HRef).To(Equal("https://api.spotify.com/v1/artists/51Blml2LZPmy7TTiAg47vQ"))
+			Expect(u2.Images[0].URL).To(Equal("https://i.scdn.co/image/e22d5c0c8139b8439440a69854ed66efae91112d"))
+			Expect(u2.Images[0].Width).To(Equal(640))
+			Expect(u2.Images[0].Height).To(Equal(640))
+			Expect(u2.Images[1].URL).To(Equal("https://i.scdn.co/image/40d6c5c14355cfc127b70da221233315497ec91d"))
+			Expect(u2.Images[1].Width).To(Equal(320))
+			Expect(u2.Images[1].Height).To(Equal(320))
+			Expect(u2.Images[2].URL).To(Equal("https://i.scdn.co/image/7293d6752ae8a64e34adee5086858e408185b534"))
+			Expect(u2.Images[2].Width).To(Equal(160))
+			Expect(u2.Images[2].Height).To(Equal(160))
+		})
+	})
+
+	Describe("Error", func() {
+		It("parses the error response correctly", func() {
+			var errorResp Error
+			body := []byte(`{"error":"invalid_client","error_description":"Invalid client"}`)
+			err := json.Unmarshal(body, &errorResp)
+			Expect(err).To(BeNil())
+
+			Expect(errorResp.Code).To(Equal("invalid_client"))
+			Expect(errorResp.Message).To(Equal("Invalid client"))
+		})
+	})
+})

core/agents/spotify/spotify.go

@@ -0,0 +1,94 @@
+package spotify
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+	"github.com/xrash/smetrics"
+)
+
+const spotifyAgentName = "spotify"
+
+type spotifyAgent struct {
+	ds     model.DataStore
+	id     string
+	secret string
+	client *Client
+}
+
+func spotifyConstructor(ds model.DataStore) agents.Interface {
+	l := &spotifyAgent{
+		ds:     ds,
+		id:     conf.Server.Spotify.ID,
+		secret: conf.Server.Spotify.Secret,
+	}
+	hc := &http.Client{
+		Timeout: consts.DefaultHttpClientTimeOut,
+	}
+	chc := utils.NewCachedHTTPClient(hc, consts.DefaultHttpClientTimeOut)
+	l.client = NewClient(l.id, l.secret, chc)
+	return l
+}
+
+func (s *spotifyAgent) AgentName() string {
+	return spotifyAgentName
+}
+
+func (s *spotifyAgent) GetImages(ctx context.Context, id, name, mbid string) ([]agents.ArtistImage, error) {
+	a, err := s.searchArtist(ctx, name)
+	if err != nil {
+		if err == model.ErrNotFound {
+			log.Warn(ctx, "Artist not found in Spotify", "artist", name)
+		} else {
+			log.Error(ctx, "Error calling Spotify", "artist", name, err)
+		}
+		return nil, err
+	}
+
+	var res []agents.ArtistImage
+	for _, img := range a.Images {
+		res = append(res, agents.ArtistImage{
+			URL:  img.URL,
+			Size: img.Width,
+		})
+	}
+	return res, nil
+}
+
+func (s *spotifyAgent) searchArtist(ctx context.Context, name string) (*Artist, error) {
+	artists, err := s.client.SearchArtists(ctx, name, 40)
+	if err != nil || len(artists) == 0 {
+		return nil, model.ErrNotFound
+	}
+	name = strings.ToLower(name)
+
+	// Sort results, prioritizing artists with images, with similar names and with high popularity, in this order
+	sort.Slice(artists, func(i, j int) bool {
+		ai := fmt.Sprintf("%-5t-%03d-%04d", len(artists[i].Images) == 0, smetrics.WagnerFischer(name, strings.ToLower(artists[i].Name), 1, 1, 2), 1000-artists[i].Popularity)
+		aj := fmt.Sprintf("%-5t-%03d-%04d", len(artists[j].Images) == 0, smetrics.WagnerFischer(name, strings.ToLower(artists[j].Name), 1, 1, 2), 1000-artists[j].Popularity)
+		return ai < aj
+	})
+
+	// If the first one has the same name, that's the one
+	if strings.ToLower(artists[0].Name) != name {
+		return nil, model.ErrNotFound
+	}
+	return &artists[0], err
+}
+
+func init() {
+	conf.AddHook(func() {
+		if conf.Server.Spotify.ID != "" && conf.Server.Spotify.Secret != "" {
+			agents.Register(spotifyAgentName, spotifyConstructor)
+		}
+	})
+}

core/agents/spotify/spotify_suite_test.go

@@ -0,0 +1,17 @@
+package spotify
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestSpotify(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Spotify Test Suite")
+}

core/archiver.go

@@ -9,8 +9,8 @@ import (
 	"path/filepath"
 
 	"github.com/Masterminds/squirrel"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
 )
 
 type Archiver interface {
@@ -30,7 +30,10 @@ type archiver struct {
 type createHeader func(idx int, mf model.MediaFile) *zip.FileHeader
 
 func (a *archiver) ZipAlbum(ctx context.Context, id string, out io.Writer) error {
-	mfs, err := a.ds.MediaFile(ctx).FindByAlbum(id)
+	mfs, err := a.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.Eq{"album_id": id},
+		Sort:    "album",
+	})
 	if err != nil {
 		log.Error(ctx, "Error loading mediafiles from album", "id", id, err)
 		return err
@@ -83,7 +86,7 @@ func (a *archiver) createHeader(idx int, mf model.MediaFile) *zip.FileHeader {
 func (a *archiver) createPlaylistHeader(idx int, mf model.MediaFile) *zip.FileHeader {
 	_, file := filepath.Split(mf.Path)
 	return &zip.FileHeader{
-		Name:     fmt.Sprintf("%d - %s-%s", idx, mf.AlbumArtist, file),
+		Name:     fmt.Sprintf("%d - %s - %s", idx+1, mf.AlbumArtist, file),
 		Modified: mf.UpdatedAt,
 		Method:   zip.Store,
 	}

core/artwork.go

@@ -8,29 +8,31 @@ import (
 	"image"
 	_ "image/gif"
 	"image/jpeg"
+	"image/png"
 	_ "image/png"
 	"io"
 	"os"
 	"strings"
+	"sync"
 	"time"
 
-	_ "golang.org/x/image/webp"
-
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/consts"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/resources"
-	"github.com/deluan/navidrome/utils"
 	"github.com/dhowden/tag"
 	"github.com/disintegration/imaging"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/resources"
+	"github.com/navidrome/navidrome/utils"
+	"github.com/navidrome/navidrome/utils/cache"
+	_ "golang.org/x/image/webp"
 )
 
 type Artwork interface {
-	Get(ctx context.Context, id string, size int, out io.Writer) error
+	Get(ctx context.Context, id string, size int) (io.ReadCloser, error)
 }
 
-type ArtworkCache FileCache
+type ArtworkCache cache.FileCache
 
 func NewArtwork(ds model.DataStore, cache ArtworkCache) Artwork {
 	return &artwork{ds: ds, cache: cache}
@@ -38,51 +40,56 @@ func NewArtwork(ds model.DataStore, cache ArtworkCache) Artwork {
 
 type artwork struct {
 	ds    model.DataStore
-	cache FileCache
+	cache cache.FileCache
 }
 
 type imageInfo struct {
-	c          *artwork
+	a          *artwork
+	id         string
 	path       string
 	size       int
 	lastUpdate time.Time
 }
 
-func (ci *imageInfo) String() string {
+func (ci *imageInfo) Key() string {
 	return fmt.Sprintf("%s.%d.%s.%d", ci.path, ci.size, ci.lastUpdate.Format(time.RFC3339Nano), conf.Server.CoverJpegQuality)
 }
 
-func (c *artwork) Get(ctx context.Context, id string, size int, out io.Writer) error {
-	path, lastUpdate, err := c.getImagePath(ctx, id)
+func (a *artwork) Get(ctx context.Context, id string, size int) (io.ReadCloser, error) {
+	path, lastUpdate, err := a.getImagePath(ctx, id)
 	if err != nil && err != model.ErrNotFound {
-		return err
+		return nil, err
+	}
+
+	if !conf.Server.DevFastAccessCoverArt {
+		if stat, err := os.Stat(path); err == nil {
+			lastUpdate = stat.ModTime()
+		}
 	}
 
 	info := &imageInfo{
-		c:          c,
+		a:          a,
+		id:         id,
 		path:       path,
 		size:       size,
 		lastUpdate: lastUpdate,
 	}
 
-	r, err := c.cache.Get(ctx, info)
+	r, err := a.cache.Get(ctx, info)
 	if err != nil {
 		log.Error(ctx, "Error accessing image cache", "path", path, "size", size, err)
-		return err
+		return nil, err
 	}
-	defer r.Close()
-
-	_, err = io.Copy(out, r)
-	return err
+	return r, err
 }
 
-func (c *artwork) getImagePath(ctx context.Context, id string) (path string, lastUpdated time.Time, err error) {
+func (a *artwork) getImagePath(ctx context.Context, id string) (path string, lastUpdated time.Time, err error) {
 	// If id is an album cover ID
 	if strings.HasPrefix(id, "al-") {
 		log.Trace(ctx, "Looking for album art", "id", id)
 		id = strings.TrimPrefix(id, "al-")
 		var al *model.Album
-		al, err = c.ds.Album(ctx).Get(id)
+		al, err = a.ds.Album(ctx).Get(id)
 		if err != nil {
 			return
 		}
@@ -94,33 +101,39 @@ func (c *artwork) getImagePath(ctx context.Context, id string) (path string, las
 
 	log.Trace(ctx, "Looking for media file art", "id", id)
 
-	// Check if id is a mediaFile cover id
+	// Check if id is a mediaFile id
 	var mf *model.MediaFile
-	mf, err = c.ds.MediaFile(ctx).Get(id)
+	mf, err = a.ds.MediaFile(ctx).Get(id)
 
 	// If it is not, may be an albumId
 	if err == model.ErrNotFound {
-		return c.getImagePath(ctx, "al-"+id)
+		return a.getImagePath(ctx, "al-"+id)
 	}
 	if err != nil {
 		return
 	}
 
-	// If it is a mediaFile and it has cover art, return it
-	if mf.HasCoverArt {
+	// If it is a mediaFile and it has cover art, return it (if feature is disabled, skip)
+	if !conf.Server.DevFastAccessCoverArt && mf.HasCoverArt {
 		return mf.Path, mf.UpdatedAt, nil
 	}
 
 	// if the mediaFile does not have a coverArt, fallback to the album cover
 	log.Trace(ctx, "Media file does not contain art. Falling back to album art", "id", id, "albumId", "al-"+mf.AlbumID)
-	return c.getImagePath(ctx, "al-"+mf.AlbumID)
+	return a.getImagePath(ctx, "al-"+mf.AlbumID)
 }
 
-func (c *artwork) getArtwork(ctx context.Context, path string, size int) (reader io.Reader, err error) {
+func (a *artwork) getArtwork(ctx context.Context, id string, path string, size int) (reader io.ReadCloser, err error) {
 	defer func() {
 		if err != nil {
 			log.Warn(ctx, "Error extracting image", "path", path, "size", size, err)
-			reader, err = resources.AssetFile().Open(consts.PlaceholderAlbumArt)
+			reader, err = resources.FS.Open(consts.PlaceholderAlbumArt)
+
+			if size != 0 && err == nil {
+				var r io.ReadCloser
+				r, err = resources.FS.Open(consts.PlaceholderAlbumArt)
+				reader, err = resizeImage(r, size, true)
+			}
 		}
 	}()
 
@@ -128,40 +141,52 @@ func (c *artwork) getArtwork(ctx context.Context, path string, size int) (reader
 		return nil, errors.New("empty path given for artwork")
 	}
 
-	var data []byte
-	if utils.IsAudioFile(path) {
-		data, err = readFromTag(path)
+	if size == 0 {
+		// If requested original size, just read from the file
+		if utils.IsAudioFile(path) {
+			reader, err = readFromTag(path)
+		} else {
+			reader, err = readFromFile(path)
+		}
 	} else {
-		data, err = readFromFile(path)
-	}
-
-	if err != nil {
-		return
-	} else if size > 0 {
-		data, err = resizeImage(bytes.NewReader(data), size)
-	}
-
-	// Confirm the image is valid. Costly, but necessary
-	_, _, err = image.Decode(bytes.NewReader(data))
-	if err == nil {
-		reader = bytes.NewReader(data)
+		// If requested a resized image, get the original (possibly from cache) and resize it
+		var r io.ReadCloser
+		r, err = a.Get(ctx, id, 0)
+		if err != nil {
+			return
+		}
+		defer r.Close()
+		reader, err = resizeImage(r, size, false)
 	}
 
 	return
 }
 
-func resizeImage(reader io.Reader, size int) ([]byte, error) {
+func resizeImage(reader io.Reader, size int, usePng bool) (io.ReadCloser, error) {
 	img, _, err := image.Decode(reader)
 	if err != nil {
 		return nil, err
 	}
-	m := imaging.Resize(img, size, size, imaging.Lanczos)
+
+	// Preserve the aspect ratio of the image.
+	var m *image.NRGBA
+	bounds := img.Bounds()
+	if bounds.Max.X > bounds.Max.Y {
+		m = imaging.Resize(img, size, 0, imaging.Lanczos)
+	} else {
+		m = imaging.Resize(img, 0, size, imaging.Lanczos)
+	}
+
 	buf := new(bytes.Buffer)
-	err = jpeg.Encode(buf, m, &jpeg.Options{Quality: conf.Server.CoverJpegQuality})
-	return buf.Bytes(), err
+	if usePng {
+		err = png.Encode(buf, m)
+	} else {
+		err = jpeg.Encode(buf, m, &jpeg.Options{Quality: conf.Server.CoverJpegQuality})
+	}
+	return io.NopCloser(buf), err
 }
 
-func readFromTag(path string) ([]byte, error) {
+func readFromTag(path string) (io.ReadCloser, error) {
 	f, err := os.Open(path)
 	if err != nil {
 		return nil, err
@@ -177,33 +202,30 @@ func readFromTag(path string) ([]byte, error) {
 	if picture == nil {
 		return nil, errors.New("file does not contain embedded art")
 	}
-	return picture.Data, nil
+	return io.NopCloser(bytes.NewReader(picture.Data)), nil
 }
 
-func readFromFile(path string) ([]byte, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-
-	defer f.Close()
-	var buf bytes.Buffer
-	if _, err := buf.ReadFrom(f); err != nil {
-		return nil, err
-	}
-
-	return buf.Bytes(), nil
+func readFromFile(path string) (io.ReadCloser, error) {
+	return os.Open(path)
 }
 
-func NewImageCache() ArtworkCache {
-	return NewFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems,
-		func(ctx context.Context, arg fmt.Stringer) (io.Reader, error) {
-			info := arg.(*imageInfo)
-			reader, err := info.c.getArtwork(ctx, info.path, info.size)
-			if err != nil {
-				log.Error(ctx, "Error loading artwork art", "path", info.path, "size", info.size, err)
-				return nil, err
-			}
-			return reader, nil
-		})
+var (
+	onceImageCache     sync.Once
+	instanceImageCache ArtworkCache
+)
+
+func GetImageCache() ArtworkCache {
+	onceImageCache.Do(func() {
+		instanceImageCache = cache.NewFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems,
+			func(ctx context.Context, arg cache.Item) (io.Reader, error) {
+				info := arg.(*imageInfo)
+				reader, err := info.a.getArtwork(ctx, info.id, info.path, info.size)
+				if err != nil {
+					log.Error(ctx, "Error loading artwork art", "path", info.path, "size", info.size, err)
+					return nil, err
+				}
+				return reader, nil
+			})
+	})
+	return instanceImageCache
 }

core/artwork_test.go

@@ -1,16 +1,14 @@
 package core
 
 import (
-	"bytes"
 	"context"
 	"image"
-	"io/ioutil"
 	"os"
 
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/persistence"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -21,121 +19,122 @@ var _ = Describe("Artwork", func() {
 	ctx := log.NewContext(context.TODO())
 
 	BeforeEach(func() {
-		ds = &persistence.MockDataStore{MockedTranscoding: &mockTranscodingRepository{}}
-		ds.Album(ctx).(*persistence.MockAlbum).SetData(`[{"id": "222", "coverArtId": "123", "coverArtPath":"tests/fixtures/test.mp3"}, {"id": "333", "coverArtId": ""}, {"id": "444", "coverArtId": "444", "coverArtPath": "tests/fixtures/cover.jpg"}]`)
-		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "albumId": "222", "path": "tests/fixtures/test.mp3", "hasCoverArt": true, "updatedAt":"2020-04-02T21:29:31.6377Z"},{"id": "456", "albumId": "222", "path": "tests/fixtures/test.ogg", "hasCoverArt": false, "updatedAt":"2020-04-02T21:29:31.6377Z"}]`)
+		ds = &tests.MockDataStore{MockedTranscoding: &tests.MockTranscodingRepo{}}
+		ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
+			{ID: "222", CoverArtId: "123", CoverArtPath: "tests/fixtures/test.mp3"},
+			{ID: "333", CoverArtId: ""},
+			{ID: "444", CoverArtId: "444", CoverArtPath: "tests/fixtures/cover.jpg"},
+		})
+		ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+			{ID: "123", AlbumID: "222", Path: "tests/fixtures/test.mp3", HasCoverArt: true},
+			{ID: "456", AlbumID: "222", Path: "tests/fixtures/test.ogg", HasCoverArt: false},
+		})
 	})
 
 	Context("Cache is configured", func() {
 		BeforeEach(func() {
-			conf.Server.DataFolder, _ = ioutil.TempDir("", "file_caches")
+			conf.Server.DataFolder, _ = os.MkdirTemp("", "file_caches")
 			conf.Server.ImageCacheSize = "100MB"
-			cache := NewImageCache()
-			Eventually(func() bool { return cache.Ready() }).Should(BeTrue())
+			cache := GetImageCache()
+			Eventually(func() bool { return cache.Ready(context.TODO()) }).Should(BeTrue())
 			artwork = NewArtwork(ds, cache)
 		})
 
-		AfterEach(func() {
-			os.RemoveAll(conf.Server.DataFolder)
-		})
-
 		It("retrieves the external artwork art for an album", func() {
-			buf := new(bytes.Buffer)
+			r, err := artwork.Get(ctx, "al-444", 0)
+			Expect(err).To(BeNil())
 
-			Expect(artwork.Get(ctx, "al-444", 0, buf)).To(BeNil())
-
-			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			_, format, err := image.Decode(r)
 			Expect(err).To(BeNil())
 			Expect(format).To(Equal("jpeg"))
+			Expect(r.Close()).To(BeNil())
 		})
 
 		It("retrieves the embedded artwork art for an album", func() {
-			buf := new(bytes.Buffer)
+			r, err := artwork.Get(ctx, "al-222", 0)
+			Expect(err).To(BeNil())
 
-			Expect(artwork.Get(ctx, "al-222", 0, buf)).To(BeNil())
-
-			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			_, format, err := image.Decode(r)
 			Expect(err).To(BeNil())
 			Expect(format).To(Equal("jpeg"))
+			Expect(r.Close()).To(BeNil())
 		})
 
 		It("returns the default artwork if album does not have artwork", func() {
-			buf := new(bytes.Buffer)
+			r, err := artwork.Get(ctx, "al-333", 0)
+			Expect(err).To(BeNil())
 
-			Expect(artwork.Get(ctx, "al-333", 0, buf)).To(BeNil())
-
-			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			_, format, err := image.Decode(r)
 			Expect(err).To(BeNil())
 			Expect(format).To(Equal("png"))
+			Expect(r.Close()).To(BeNil())
 		})
 
 		It("returns the default artwork if album is not found", func() {
-			buf := new(bytes.Buffer)
+			r, err := artwork.Get(ctx, "al-0101", 0)
+			Expect(err).To(BeNil())
 
-			Expect(artwork.Get(ctx, "al-0101", 0, buf)).To(BeNil())
-
-			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			_, format, err := image.Decode(r)
 			Expect(err).To(BeNil())
 			Expect(format).To(Equal("png"))
+			Expect(r.Close()).To(BeNil())
 		})
 
 		It("retrieves the original artwork art from a media_file", func() {
-			buf := new(bytes.Buffer)
+			r, err := artwork.Get(ctx, "123", 0)
+			Expect(err).To(BeNil())
 
-			Expect(artwork.Get(ctx, "123", 0, buf)).To(BeNil())
-
-			img, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			img, format, err := image.Decode(r)
 			Expect(err).To(BeNil())
 			Expect(format).To(Equal("jpeg"))
 			Expect(img.Bounds().Size().X).To(Equal(600))
 			Expect(img.Bounds().Size().Y).To(Equal(600))
+			Expect(r.Close()).To(BeNil())
 		})
 
 		It("retrieves the album artwork art if media_file does not have one", func() {
-			buf := new(bytes.Buffer)
+			r, err := artwork.Get(ctx, "456", 0)
+			Expect(err).To(BeNil())
 
-			Expect(artwork.Get(ctx, "456", 0, buf)).To(BeNil())
-
-			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			_, format, err := image.Decode(r)
 			Expect(err).To(BeNil())
 			Expect(format).To(Equal("jpeg"))
+			Expect(r.Close()).To(BeNil())
 		})
 
 		It("retrieves the album artwork by album id", func() {
-			buf := new(bytes.Buffer)
+			r, err := artwork.Get(ctx, "222", 0)
+			Expect(err).To(BeNil())
 
-			Expect(artwork.Get(ctx, "222", 0, buf)).To(BeNil())
-
-			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			_, format, err := image.Decode(r)
 			Expect(err).To(BeNil())
 			Expect(format).To(Equal("jpeg"))
+			Expect(r.Close()).To(BeNil())
 		})
 
 		It("resized artwork art as requested", func() {
-			buf := new(bytes.Buffer)
+			r, err := artwork.Get(ctx, "123", 200)
+			Expect(err).To(BeNil())
 
-			Expect(artwork.Get(ctx, "123", 200, buf)).To(BeNil())
-
-			img, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			img, format, err := image.Decode(r)
 			Expect(err).To(BeNil())
 			Expect(format).To(Equal("jpeg"))
 			Expect(img.Bounds().Size().X).To(Equal(200))
 			Expect(img.Bounds().Size().Y).To(Equal(200))
+			Expect(r.Close()).To(BeNil())
 		})
 
 		Context("Errors", func() {
 			It("returns err if gets error from album table", func() {
-				ds.Album(ctx).(*persistence.MockAlbum).SetError(true)
-				buf := new(bytes.Buffer)
-
-				Expect(artwork.Get(ctx, "al-222", 0, buf)).To(MatchError("Error!"))
+				ds.Album(ctx).(*tests.MockAlbumRepo).SetError(true)
+				_, err := artwork.Get(ctx, "al-222", 0)
+				Expect(err).To(MatchError("Error!"))
 			})
 
 			It("returns err if gets error from media_file table", func() {
-				ds.MediaFile(ctx).(*persistence.MockMediaFile).SetError(true)
-				buf := new(bytes.Buffer)
-
-				Expect(artwork.Get(ctx, "123", 0, buf)).To(MatchError("Error!"))
+				ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetError(true)
+				_, err := artwork.Get(ctx, "123", 0)
+				Expect(err).To(MatchError("Error!"))
 			})
 		})
 	})

core/auth/auth.go

@@ -2,75 +2,66 @@ package auth
 
 import (
 	"context"
-	"fmt"
 	"sync"
 	"time"
 
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/consts"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/dgrijalva/jwt-go"
-	"github.com/go-chi/jwtauth"
+	"github.com/go-chi/jwtauth/v5"
+	"github.com/lestrrat-go/jwx/jwt"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
 )
 
 var (
-	once           sync.Once
-	JwtSecret      []byte
-	TokenAuth      *jwtauth.JWTAuth
-	sessionTimeOut time.Duration
+	once      sync.Once
+	Secret    []byte
+	TokenAuth *jwtauth.JWTAuth
 )
 
-func InitTokenAuth(ds model.DataStore) {
+func Init(ds model.DataStore) {
 	once.Do(func() {
+		log.Info("Setting Session Timeout", "value", conf.Server.SessionTimeout)
 		secret, err := ds.Property(context.TODO()).DefaultGet(consts.JWTSecretKey, "not so secret")
 		if err != nil {
 			log.Error("No JWT secret found in DB. Setting a temp one, but please report this error", err)
 		}
-		JwtSecret = []byte(secret)
-		TokenAuth = jwtauth.New("HS256", JwtSecret, nil)
+		Secret = []byte(secret)
+		TokenAuth = jwtauth.New("HS256", Secret, nil)
 	})
 }
 
 func CreateToken(u *model.User) (string, error) {
-	token := jwt.New(jwt.SigningMethodHS256)
-	claims := token.Claims.(jwt.MapClaims)
-	claims["iss"] = consts.JWTIssuer
-	claims["sub"] = u.UserName
+	claims := map[string]interface{}{}
+	claims[jwt.IssuerKey] = consts.JWTIssuer
+	claims[jwt.IssuedAtKey] = time.Now().UTC().Unix()
+	claims[jwt.SubjectKey] = u.UserName
+	claims["uid"] = u.ID
 	claims["adm"] = u.IsAdmin
+	token, _, err := TokenAuth.Encode(claims)
+	if err != nil {
+		return "", err
+	}
 
 	return TouchToken(token)
 }
 
-func getSessionTimeOut() time.Duration {
-	if sessionTimeOut == 0 {
-		sessionTimeOut = conf.Server.SessionTimeout
-		log.Info("Setting Session Timeout", "value", sessionTimeOut)
+func TouchToken(token jwt.Token) (string, error) {
+	claims, err := token.AsMap(context.Background())
+	if err != nil {
+		return "", err
 	}
-	return sessionTimeOut
+
+	claims[jwt.ExpirationKey] = time.Now().UTC().Add(conf.Server.SessionTimeout).Unix()
+	_, newToken, err := TokenAuth.Encode(claims)
+
+	return newToken, err
 }
 
-func TouchToken(token *jwt.Token) (string, error) {
-	timeout := getSessionTimeOut()
-	expireIn := time.Now().Add(timeout).Unix()
-	claims := token.Claims.(jwt.MapClaims)
-	claims["exp"] = expireIn
-
-	return token.SignedString(JwtSecret)
-}
-
-func Validate(tokenStr string) (jwt.MapClaims, error) {
-	token, err := jwt.Parse(tokenStr, func(token *jwt.Token) (interface{}, error) {
-		// Don't forget to validate the alg is what you expect:
-		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
-			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
-		}
-
-		// hmacSampleSecret is a []byte containing your secret, e.g. []byte("my_secret_key")
-		return JwtSecret, nil
-	})
+func Validate(tokenStr string) (map[string]interface{}, error) {
+	token, err := jwtauth.VerifyToken(TokenAuth, tokenStr)
 	if err != nil {
 		return nil, err
 	}
-	return token.Claims.(jwt.MapClaims), err
+	return token.AsMap(context.Background())
 }

core/auth/auth_test.go

@@ -4,9 +4,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/deluan/navidrome/core/auth"
-	"github.com/deluan/navidrome/log"
-	"github.com/dgrijalva/jwt-go"
+	"github.com/go-chi/jwtauth/v5"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/auth"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -17,39 +20,89 @@ func TestAuth(t *testing.T) {
 	RunSpecs(t, "Auth Test Suite")
 }
 
-const testJWTSecret = "not so secret"
+const (
+	testJWTSecret = "not so secret"
+	oneDay        = 24 * time.Hour
+)
 
 var _ = Describe("Auth", func() {
-	BeforeEach(func() {
-		auth.JwtSecret = []byte(testJWTSecret)
+	BeforeSuite(func() {
+		conf.Server.SessionTimeout = 2 * oneDay
 	})
-	Context("Validate", func() {
+
+	BeforeEach(func() {
+		auth.Secret = []byte(testJWTSecret)
+		auth.TokenAuth = jwtauth.New("HS256", auth.Secret, nil)
+	})
+
+	Describe("Validate", func() {
 		It("returns error with an invalid JWT token", func() {
 			_, err := auth.Validate("invalid.token")
-			Expect(err).To(Not(BeNil()))
+			Expect(err).To(HaveOccurred())
 		})
 
 		It("returns the claims from a valid JWT token", func() {
-			token := jwt.New(jwt.SigningMethodHS256)
-			claims := token.Claims.(jwt.MapClaims)
+			claims := map[string]interface{}{}
 			claims["iss"] = "issuer"
+			claims["iat"] = time.Now().Unix()
 			claims["exp"] = time.Now().Add(1 * time.Minute).Unix()
-			tokenStr, _ := token.SignedString(auth.JwtSecret)
+			_, tokenStr, err := auth.TokenAuth.Encode(claims)
+			Expect(err).NotTo(HaveOccurred())
 
 			decodedClaims, err := auth.Validate(tokenStr)
-			Expect(err).To(BeNil())
+			Expect(err).NotTo(HaveOccurred())
 			Expect(decodedClaims["iss"]).To(Equal("issuer"))
 		})
 
 		It("returns ErrExpired if the `exp` field is in the past", func() {
-			token := jwt.New(jwt.SigningMethodHS256)
-			claims := token.Claims.(jwt.MapClaims)
+			claims := map[string]interface{}{}
 			claims["iss"] = "issuer"
 			claims["exp"] = time.Now().Add(-1 * time.Minute).Unix()
-			tokenStr, _ := token.SignedString(auth.JwtSecret)
+			_, tokenStr, err := auth.TokenAuth.Encode(claims)
+			Expect(err).NotTo(HaveOccurred())
 
-			_, err := auth.Validate(tokenStr)
-			Expect(err).To(MatchError("Token is expired"))
+			_, err = auth.Validate(tokenStr)
+			Expect(err).To(MatchError("token is expired"))
+		})
+	})
+
+	Describe("CreateToken", func() {
+		It("creates a valid token", func() {
+			u := &model.User{
+				ID:       "123",
+				UserName: "johndoe",
+				IsAdmin:  true,
+			}
+			tokenStr, err := auth.CreateToken(u)
+			Expect(err).NotTo(HaveOccurred())
+
+			claims, err := auth.Validate(tokenStr)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(claims["iss"]).To(Equal(consts.JWTIssuer))
+			Expect(claims["sub"]).To(Equal("johndoe"))
+			Expect(claims["uid"]).To(Equal("123"))
+			Expect(claims["adm"]).To(Equal(true))
+			Expect(claims["exp"]).To(BeTemporally(">", time.Now()))
+		})
+	})
+
+	Describe("TouchToken", func() {
+		It("updates the expiration time", func() {
+			yesterday := time.Now().Add(-oneDay)
+			claims := map[string]interface{}{}
+			claims["iss"] = "issuer"
+			claims["exp"] = yesterday.Unix()
+			token, _, err := auth.TokenAuth.Encode(claims)
+			Expect(err).NotTo(HaveOccurred())
+
+			touched, err := auth.TouchToken(token)
+			Expect(err).NotTo(HaveOccurred())
+
+			decodedClaims, err := auth.Validate(touched)
+			Expect(err).NotTo(HaveOccurred())
+			exp := decodedClaims["exp"].(time.Time)
+			Expect(exp.Sub(yesterday)).To(BeNumerically(">=", oneDay))
 		})
 	})
 })

core/cache_warmer.go

@@ -0,0 +1,87 @@
+package core
+
+import (
+	"context"
+	"io"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/utils/pool"
+)
+
+type CacheWarmer interface {
+	AddAlbum(ctx context.Context, albumID string)
+	Flush(ctx context.Context)
+}
+
+func NewCacheWarmer(artwork Artwork, artworkCache ArtworkCache) CacheWarmer {
+	w := &warmer{
+		artwork:      artwork,
+		artworkCache: artworkCache,
+		albums:       map[string]struct{}{},
+	}
+	p, err := pool.NewPool("artwork", 3, w.execute)
+	if err != nil {
+		log.Error(context.Background(), "Error creating pool for Album Artwork Cache Warmer", err)
+	} else {
+		w.pool = p
+	}
+
+	return w
+}
+
+type warmer struct {
+	pool         *pool.Pool
+	artwork      Artwork
+	artworkCache ArtworkCache
+	albums       map[string]struct{}
+}
+
+func (w *warmer) AddAlbum(ctx context.Context, albumID string) {
+	if albumID == "" {
+		return
+	}
+	w.albums[albumID] = struct{}{}
+}
+
+func (w *warmer) waitForCacheReady(ctx context.Context) {
+	for !w.artworkCache.Ready(ctx) {
+		time.Sleep(time.Second)
+	}
+}
+
+func (w *warmer) Flush(ctx context.Context) {
+	if conf.Server.DevPreCacheAlbumArtwork {
+		w.waitForCacheReady(ctx)
+		if w.artworkCache.Available(ctx) {
+			if w.pool == nil || len(w.albums) == 0 {
+				return
+			}
+			log.Info(ctx, "Pre-caching album artworks", "numAlbums", len(w.albums))
+			for id := range w.albums {
+				w.pool.Submit(artworkItem{albumID: id})
+			}
+		} else {
+			log.Warn(ctx, "Cache warmer is not available as ImageCache is DISABLED")
+		}
+	}
+	w.albums = map[string]struct{}{}
+}
+
+func (w *warmer) execute(workload interface{}) {
+	ctx := context.Background()
+	item := workload.(artworkItem)
+	log.Trace(ctx, "Pre-caching album artwork", "albumID", item.albumID)
+	r, err := w.artwork.Get(ctx, item.albumID, 0)
+	if err != nil {
+		log.Warn("Error pre-caching artwork from album", "id", item.albumID, err)
+		return
+	}
+	defer r.Close()
+	_, _ = io.Copy(io.Discard, r)
+}
+
+type artworkItem struct {
+	albumID string
+}

core/common.go

@@ -3,7 +3,7 @@ package core
 import (
 	"context"
 
-	"github.com/deluan/navidrome/model/request"
+	"github.com/navidrome/navidrome/model/request"
 )
 
 func userName(ctx context.Context) string {

core/core_suite_test.go

@@ -3,13 +3,13 @@ package core
 import (
 	"testing"
 
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/tests"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
-func TestEngine(t *testing.T) {
+func TestCore(t *testing.T) {
 	tests.Init(t, false)
 	log.SetLevel(log.LevelCritical)
 	RegisterFailHandler(Fail)

core/external_metadata.go

@@ -0,0 +1,395 @@
+package core
+
+import (
+	"context"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/microcosm-cc/bluemonday"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/agents"
+	_ "github.com/navidrome/navidrome/core/agents/lastfm"
+	_ "github.com/navidrome/navidrome/core/agents/spotify"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/utils"
+)
+
+const (
+	unavailableArtistID = "-1"
+	maxSimilarArtists   = 100
+)
+
+type ExternalMetadata interface {
+	UpdateArtistInfo(ctx context.Context, id string, count int, includeNotPresent bool) (*model.Artist, error)
+	SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error)
+	TopSongs(ctx context.Context, artist string, count int) (model.MediaFiles, error)
+}
+
+type externalMetadata struct {
+	ds model.DataStore
+	ag *agents.Agents
+}
+
+type auxArtist struct {
+	model.Artist
+	Name string
+}
+
+func NewExternalMetadata(ds model.DataStore, agents *agents.Agents) ExternalMetadata {
+	return &externalMetadata{ds: ds, ag: agents}
+}
+
+func (e *externalMetadata) getArtist(ctx context.Context, id string) (*auxArtist, error) {
+	var entity interface{}
+	entity, err := GetEntityByID(ctx, e.ds, id)
+	if err != nil {
+		return nil, err
+	}
+
+	var artist auxArtist
+	switch v := entity.(type) {
+	case *model.Artist:
+		artist.Artist = *v
+		artist.Name = clearName(v.Name)
+	case *model.MediaFile:
+		return e.getArtist(ctx, v.ArtistID)
+	case *model.Album:
+		return e.getArtist(ctx, v.AlbumArtistID)
+	default:
+		return nil, model.ErrNotFound
+	}
+	return &artist, nil
+}
+
+// Replace some Unicode chars with their equivalent ASCII
+func clearName(name string) string {
+	name = strings.ReplaceAll(name, "–", "-")
+	name = strings.ReplaceAll(name, "‐", "-")
+	name = strings.ReplaceAll(name, "“", `"`)
+	name = strings.ReplaceAll(name, "”", `"`)
+	name = strings.ReplaceAll(name, "‘", `'`)
+	name = strings.ReplaceAll(name, "’", `'`)
+	return name
+}
+
+func (e *externalMetadata) UpdateArtistInfo(ctx context.Context, id string, similarCount int, includeNotPresent bool) (*model.Artist, error) {
+	artist, err := e.getArtist(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	// If we have fresh info, just return it and trigger a refresh in the background
+	if time.Since(artist.ExternalInfoUpdatedAt) < consts.ArtistInfoTimeToLive {
+		go func() {
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			err := e.refreshArtistInfo(ctx, artist)
+			if err != nil {
+				log.Error("Error refreshing ArtistInfo", "id", id, "name", artist.Name, err)
+			}
+		}()
+		log.Debug("Found cached ArtistInfo, refreshing in the background", "updatedAt", artist.ExternalInfoUpdatedAt, "name", artist.Name)
+		err := e.loadSimilar(ctx, artist, similarCount, includeNotPresent)
+		return &artist.Artist, err
+	}
+
+	log.Debug(ctx, "ArtistInfo not cached or expired", "updatedAt", artist.ExternalInfoUpdatedAt, "id", id, "name", artist.Name)
+	err = e.refreshArtistInfo(ctx, artist)
+	if err != nil {
+		return nil, err
+	}
+	err = e.loadSimilar(ctx, artist, similarCount, includeNotPresent)
+	return &artist.Artist, err
+}
+
+func (e *externalMetadata) refreshArtistInfo(ctx context.Context, artist *auxArtist) error {
+	// Get MBID first, if it is not yet available
+	if artist.MbzArtistID == "" {
+		mbid, err := e.ag.GetMBID(ctx, artist.ID, artist.Name)
+		if mbid != "" && err == nil {
+			artist.MbzArtistID = mbid
+		}
+	}
+
+	// Call all registered agents and collect information
+	callParallel([]func(){
+		func() { e.callGetBiography(ctx, e.ag, artist) },
+		func() { e.callGetURL(ctx, e.ag, artist) },
+		func() { e.callGetImage(ctx, e.ag, artist) },
+		func() { e.callGetSimilar(ctx, e.ag, artist, maxSimilarArtists, true) },
+	})
+
+	if utils.IsCtxDone(ctx) {
+		log.Warn(ctx, "ArtistInfo update canceled", ctx.Err())
+		return ctx.Err()
+	}
+
+	artist.ExternalInfoUpdatedAt = time.Now()
+	err := e.ds.Artist(ctx).Put(&artist.Artist)
+	if err != nil {
+		log.Error(ctx, "Error trying to update artist external information", "id", artist.ID, "name", artist.Name, err)
+	}
+
+	log.Trace(ctx, "ArtistInfo collected", "artist", artist)
+	return nil
+}
+
+func callParallel(fs []func()) {
+	wg := &sync.WaitGroup{}
+	wg.Add(len(fs))
+	for _, f := range fs {
+		go func(f func()) {
+			f()
+			wg.Done()
+		}(f)
+	}
+	wg.Wait()
+}
+
+func (e *externalMetadata) SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error) {
+	artist, err := e.getArtist(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	e.callGetSimilar(ctx, e.ag, artist, 15, false)
+	if utils.IsCtxDone(ctx) {
+		log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+		return nil, ctx.Err()
+	}
+
+	artists := model.Artists{artist.Artist}
+	artists = append(artists, artist.SimilarArtists...)
+
+	weightedSongs := utils.NewWeightedRandomChooser()
+	for _, a := range artists {
+		if utils.IsCtxDone(ctx) {
+			log.Warn(ctx, "SimilarSongs call canceled", ctx.Err())
+			return nil, ctx.Err()
+		}
+
+		topCount := utils.MaxInt(count, 20)
+		topSongs, err := e.getMatchingTopSongs(ctx, e.ag, &auxArtist{Name: a.Name, Artist: a}, topCount)
+		if err != nil {
+			log.Warn(ctx, "Error getting artist's top songs", "artist", a.Name, err)
+			continue
+		}
+
+		weight := topCount * 4
+		for _, mf := range topSongs {
+			weightedSongs.Put(mf, weight)
+			weight -= 4
+		}
+	}
+
+	var similarSongs model.MediaFiles
+	for len(similarSongs) < count && weightedSongs.Size() > 0 {
+		s, err := weightedSongs.GetAndRemove()
+		if err != nil {
+			log.Warn(ctx, "Error getting weighted song", err)
+			continue
+		}
+		similarSongs = append(similarSongs, s.(model.MediaFile))
+	}
+
+	return similarSongs, nil
+}
+
+func (e *externalMetadata) TopSongs(ctx context.Context, artistName string, count int) (model.MediaFiles, error) {
+	artist, err := e.findArtistByName(ctx, artistName)
+	if err != nil {
+		log.Error(ctx, "Artist not found", "name", artistName, err)
+		return nil, nil
+	}
+
+	return e.getMatchingTopSongs(ctx, e.ag, artist, count)
+}
+
+func (e *externalMetadata) getMatchingTopSongs(ctx context.Context, agent agents.ArtistTopSongsRetriever, artist *auxArtist, count int) (model.MediaFiles, error) {
+	songs, err := agent.GetTopSongs(ctx, artist.ID, artist.Name, artist.MbzArtistID, count)
+	if err != nil {
+		return nil, err
+	}
+
+	var mfs model.MediaFiles
+	for _, t := range songs {
+		mf, err := e.findMatchingTrack(ctx, t.MBID, artist.ID, t.Name)
+		if err != nil {
+			continue
+		}
+		mfs = append(mfs, *mf)
+		if len(mfs) == count {
+			break
+		}
+	}
+	if len(mfs) == 0 {
+		log.Debug(ctx, "No matching top songs found", "name", artist.Name)
+	} else {
+		log.Debug(ctx, "Found matching top songs", "name", artist.Name, "numSongs", len(mfs))
+	}
+	return mfs, nil
+}
+
+func (e *externalMetadata) findMatchingTrack(ctx context.Context, mbid string, artistID, title string) (*model.MediaFile, error) {
+	if mbid != "" {
+		mfs, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+			Filters: squirrel.Eq{"mbz_track_id": mbid},
+		})
+		if err == nil && len(mfs) > 0 {
+			return &mfs[0], nil
+		}
+	}
+	mfs, err := e.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.And{
+			squirrel.Or{
+				squirrel.Eq{"artist_id": artistID},
+				squirrel.Eq{"album_artist_id": artistID},
+			},
+			squirrel.Like{"title": title},
+		},
+		Sort: "starred desc, rating desc, year asc",
+	})
+	if err != nil || len(mfs) == 0 {
+		return nil, model.ErrNotFound
+	}
+	return &mfs[0], nil
+}
+
+func (e *externalMetadata) callGetURL(ctx context.Context, agent agents.ArtistURLRetriever, artist *auxArtist) {
+	url, err := agent.GetURL(ctx, artist.ID, artist.Name, artist.MbzArtistID)
+	if url == "" || err != nil {
+		return
+	}
+	artist.ExternalUrl = url
+}
+
+func (e *externalMetadata) callGetBiography(ctx context.Context, agent agents.ArtistBiographyRetriever, artist *auxArtist) {
+	bio, err := agent.GetBiography(ctx, artist.ID, clearName(artist.Name), artist.MbzArtistID)
+	if bio == "" || err != nil {
+		return
+	}
+	policy := bluemonday.UGCPolicy()
+	bio = policy.Sanitize(bio)
+	bio = strings.ReplaceAll(bio, "\n", " ")
+	artist.Biography = strings.ReplaceAll(bio, "<a ", "<a target='_blank' ")
+}
+
+func (e *externalMetadata) callGetImage(ctx context.Context, agent agents.ArtistImageRetriever, artist *auxArtist) {
+	images, err := agent.GetImages(ctx, artist.ID, artist.Name, artist.MbzArtistID)
+	if len(images) == 0 || err != nil {
+		return
+	}
+	sort.Slice(images, func(i, j int) bool { return images[i].Size > images[j].Size })
+
+	if len(images) >= 1 {
+		artist.LargeImageUrl = images[0].URL
+	}
+	if len(images) >= 2 {
+		artist.MediumImageUrl = images[1].URL
+	}
+	if len(images) >= 3 {
+		artist.SmallImageUrl = images[2].URL
+	}
+}
+
+func (e *externalMetadata) callGetSimilar(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,
+	limit int, includeNotPresent bool) {
+	similar, err := agent.GetSimilar(ctx, artist.ID, artist.Name, artist.MbzArtistID, limit)
+	if len(similar) == 0 || err != nil {
+		return
+	}
+	sa, err := e.mapSimilarArtists(ctx, similar, includeNotPresent)
+	if err != nil {
+		return
+	}
+	artist.SimilarArtists = sa
+}
+
+func (e *externalMetadata) mapSimilarArtists(ctx context.Context, similar []agents.Artist, includeNotPresent bool) (model.Artists, error) {
+	var result model.Artists
+	var notPresent []string
+
+	// First select artists that are present.
+	for _, s := range similar {
+		sa, err := e.findArtistByName(ctx, s.Name)
+		if err != nil {
+			notPresent = append(notPresent, s.Name)
+			continue
+		}
+		result = append(result, sa.Artist)
+	}
+
+	// Then fill up with non-present artists
+	if includeNotPresent {
+		for _, s := range notPresent {
+			sa := model.Artist{ID: unavailableArtistID, Name: s}
+			result = append(result, sa)
+		}
+	}
+
+	return result, nil
+}
+
+func (e *externalMetadata) findArtistByName(ctx context.Context, artistName string) (*auxArtist, error) {
+	artists, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.Like{"artist.name": artistName},
+		Max:     1,
+	})
+	if err != nil {
+		return nil, err
+	}
+	if len(artists) == 0 {
+		return nil, model.ErrNotFound
+	}
+	artist := &auxArtist{
+		Artist: artists[0],
+		Name:   clearName(artists[0].Name),
+	}
+	return artist, nil
+}
+
+func (e *externalMetadata) loadSimilar(ctx context.Context, artist *auxArtist, count int, includeNotPresent bool) error {
+	var ids []string
+	for _, sa := range artist.SimilarArtists {
+		if sa.ID == unavailableArtistID {
+			continue
+		}
+		ids = append(ids, sa.ID)
+	}
+
+	similar, err := e.ds.Artist(ctx).GetAll(model.QueryOptions{
+		Filters: squirrel.Eq{"artist.id": ids},
+	})
+	if err != nil {
+		log.Error("Error loading similar artists", "id", artist.ID, "name", artist.Name, err)
+		return err
+	}
+
+	// Use a map and iterate through original array, to keep the same order
+	artistMap := make(map[string]model.Artist)
+	for _, sa := range similar {
+		artistMap[sa.ID] = sa
+	}
+
+	var loaded model.Artists
+	for _, sa := range artist.SimilarArtists {
+		if len(loaded) >= count {
+			break
+		}
+		la, ok := artistMap[sa.ID]
+		if !ok {
+			if !includeNotPresent {
+				continue
+			}
+			la = sa
+			la.ID = unavailableArtistID
+		}
+		loaded = append(loaded, la)
+	}
+	artist.SimilarArtists = loaded
+	return nil
+}

core/get_entity.go

@@ -0,0 +1,28 @@
+package core
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+// TODO: Should the type be encoded in the ID?
+func GetEntityByID(ctx context.Context, ds model.DataStore, id string) (interface{}, error) {
+	ar, err := ds.Artist(ctx).Get(id)
+	if err == nil {
+		return ar, nil
+	}
+	al, err := ds.Album(ctx).Get(id)
+	if err == nil {
+		return al, nil
+	}
+	pls, err := ds.Playlist(ctx).Get(id)
+	if err == nil {
+		return pls, nil
+	}
+	mf, err := ds.MediaFile(ctx).Get(id)
+	if err == nil {
+		return mf, nil
+	}
+	return nil, err
+}

core/media_streamer.go

@@ -6,30 +6,32 @@ import (
 	"io"
 	"mime"
 	"os"
+	"sync"
 	"time"
 
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/consts"
-	"github.com/deluan/navidrome/core/transcoder"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/model/request"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/core/transcoder"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/utils/cache"
 )
 
 type MediaStreamer interface {
 	NewStream(ctx context.Context, id string, reqFormat string, reqBitRate int) (*Stream, error)
 }
 
-type TranscodingCache FileCache
+type TranscodingCache cache.FileCache
 
-func NewMediaStreamer(ds model.DataStore, ffm transcoder.Transcoder, cache TranscodingCache) MediaStreamer {
-	return &mediaStreamer{ds: ds, ffm: ffm, cache: cache}
+func NewMediaStreamer(ds model.DataStore, t transcoder.Transcoder, cache TranscodingCache) MediaStreamer {
+	return &mediaStreamer{ds: ds, transcoder: t, cache: cache}
 }
 
 type mediaStreamer struct {
-	ds    model.DataStore
-	ffm   transcoder.Transcoder
-	cache FileCache
+	ds         model.DataStore
+	transcoder transcoder.Transcoder
+	cache      cache.FileCache
 }
 
 type streamJob struct {
@@ -39,7 +41,7 @@ type streamJob struct {
 	bitRate int
 }
 
-func (j *streamJob) String() string {
+func (j *streamJob) Key() string {
 	return fmt.Sprintf("%s.%s.%d.%s", j.mf.ID, j.mf.UpdatedAt.Format(time.RFC3339Nano), j.bitRate, j.format)
 }
 
@@ -89,16 +91,14 @@ func (ms *mediaStreamer) NewStream(ctx context.Context, id string, reqFormat str
 	}
 	cached = r.Cached
 
+	s.ReadCloser = r
+	s.Seeker = r.Seeker
+
 	log.Debug(ctx, "Streaming TRANSCODED file", "id", mf.ID, "path", mf.Path,
 		"requestBitrate", reqBitRate, "requestFormat", reqFormat,
 		"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix,
 		"selectedBitrate", bitRate, "selectedFormat", format, "cached", cached, "seekable", s.Seekable())
 
-	s.ReadCloser = r
-	if r.Seekable() {
-		s.Seeker = r
-	}
-
 	return s, nil
 }
 
@@ -166,21 +166,29 @@ func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model
 	return
 }
 
-func NewTranscodingCache() TranscodingCache {
-	return NewFileCache("Transcoding", conf.Server.TranscodingCacheSize,
-		consts.TranscodingCacheDir, consts.DefaultTranscodingCacheMaxItems,
-		func(ctx context.Context, arg fmt.Stringer) (io.Reader, error) {
-			job := arg.(*streamJob)
-			t, err := job.ms.ds.Transcoding(ctx).FindByFormat(job.format)
-			if err != nil {
-				log.Error(ctx, "Error loading transcoding command", "format", job.format, err)
-				return nil, os.ErrInvalid
-			}
-			out, err := job.ms.ffm.Start(ctx, t.Command, job.mf.Path, job.bitRate)
-			if err != nil {
-				log.Error(ctx, "Error starting transcoder", "id", job.mf.ID, err)
-				return nil, os.ErrInvalid
-			}
-			return out, nil
-		})
+var (
+	onceTranscodingCache     sync.Once
+	instanceTranscodingCache TranscodingCache
+)
+
+func GetTranscodingCache() TranscodingCache {
+	onceTranscodingCache.Do(func() {
+		instanceTranscodingCache = cache.NewFileCache("Transcoding", conf.Server.TranscodingCacheSize,
+			consts.TranscodingCacheDir, consts.DefaultTranscodingCacheMaxItems,
+			func(ctx context.Context, arg cache.Item) (io.Reader, error) {
+				job := arg.(*streamJob)
+				t, err := job.ms.ds.Transcoding(ctx).FindByFormat(job.format)
+				if err != nil {
+					log.Error(ctx, "Error loading transcoding command", "format", job.format, err)
+					return nil, os.ErrInvalid
+				}
+				out, err := job.ms.transcoder.Start(ctx, t.Command, job.mf.Path, job.bitRate)
+				if err != nil {
+					log.Error(ctx, "Error starting transcoder", "id", job.mf.ID, err)
+					return nil, os.ErrInvalid
+				}
+				return out, nil
+			})
+	})
+	return instanceTranscodingCache
 }

core/media_streamer_test.go

@@ -3,15 +3,14 @@ package core
 import (
 	"context"
 	"io"
-	"io/ioutil"
 	"os"
 	"strings"
 
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/model/request"
-	"github.com/deluan/navidrome/persistence"
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -23,19 +22,17 @@ var _ = Describe("MediaStreamer", func() {
 	ctx := log.NewContext(context.TODO())
 
 	BeforeEach(func() {
-		conf.Server.DataFolder, _ = ioutil.TempDir("", "file_caches")
+		conf.Server.DataFolder, _ = os.MkdirTemp("", "file_caches")
 		conf.Server.TranscodingCacheSize = "100MB"
-		ds = &persistence.MockDataStore{MockedTranscoding: &mockTranscodingRepository{}}
-		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "suffix": "mp3", "bitRate": 128, "duration": 257.0}]`)
-		testCache := NewTranscodingCache()
-		Eventually(func() bool { return testCache.Ready() }).Should(BeTrue())
+		ds = &tests.MockDataStore{MockedTranscoding: &tests.MockTranscodingRepo{}}
+		ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+			{ID: "123", Path: "tests/fixtures/test.mp3", Suffix: "mp3", BitRate: 128, Duration: 257.0},
+		})
+		testCache := GetTranscodingCache()
+		Eventually(func() bool { return testCache.Ready(context.TODO()) }).Should(BeTrue())
 		streamer = NewMediaStreamer(ds, ffmpeg, testCache)
 	})
 
-	AfterEach(func() {
-		os.RemoveAll(conf.Server.DataFolder)
-	})
-
 	Context("NewStream", func() {
 		It("returns a seekable stream if format is 'raw'", func() {
 			s, err := streamer.NewStream(ctx, "123", "raw", 0)
@@ -61,7 +58,7 @@ var _ = Describe("MediaStreamer", func() {
 		It("returns a seekable stream if the file is complete in the cache", func() {
 			s, err := streamer.NewStream(ctx, "123", "mp3", 32)
 			Expect(err).To(BeNil())
-			_, _ = ioutil.ReadAll(s)
+			_, _ = io.ReadAll(s)
 			_ = s.Close()
 			Eventually(func() bool { return ffmpeg.closed }, "3s").Should(BeTrue())
 

core/players.go

@@ -1,14 +1,14 @@
-package engine
+package core
 
 import (
 	"context"
 	"fmt"
 	"time"
 
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/model/request"
 	"github.com/google/uuid"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
 )
 
 type Players interface {
@@ -24,7 +24,7 @@ type players struct {
 	ds model.DataStore
 }
 
-func (p *players) Register(ctx context.Context, id, client, typ, ip string) (*model.Player, *model.Transcoding, error) {
+func (p *players) Register(ctx context.Context, id, client, userAgent, ip string) (*model.Player, *model.Transcoding, error) {
 	var plr *model.Player
 	var trc *model.Transcoding
 	var err error
@@ -36,23 +36,23 @@ func (p *players) Register(ctx context.Context, id, client, typ, ip string) (*mo
 		}
 	}
 	if err != nil || id == "" {
-		plr, err = p.ds.Player(ctx).FindByName(client, userName)
+		plr, err = p.ds.Player(ctx).FindMatch(userName, client, userAgent)
 		if err == nil {
-			log.Debug("Found player by name", "id", plr.ID, "client", client, "username", userName)
+			log.Debug("Found matching player", "id", plr.ID, "client", client, "username", userName, "type", userAgent)
 		} else {
-			r, _ := uuid.NewRandom()
 			plr = &model.Player{
-				ID:       r.String(),
-				Name:     fmt.Sprintf("%s (%s)", client, userName),
-				UserName: userName,
-				Client:   client,
+				ID:              uuid.NewString(),
+				UserName:        userName,
+				Client:          client,
+				ScrobbleEnabled: true,
 			}
-			log.Info("Registering new player", "id", plr.ID, "client", client, "username", userName)
+			log.Info("Registering new player", "id", plr.ID, "client", client, "username", userName, "type", userAgent)
 		}
 	}
-	plr.LastSeen = time.Now()
-	plr.Type = typ
+	plr.Name = fmt.Sprintf("%s [%s]", client, userAgent)
+	plr.UserAgent = userAgent
 	plr.IPAddress = ip
+	plr.LastSeen = time.Now()
 	err = p.ds.Player(ctx).Put(plr)
 	if err != nil {
 		return nil, nil, err

core/players_test.go

@@ -1,13 +1,13 @@
-package engine
+package core
 
 import (
 	"context"
 	"time"
 
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/model/request"
-	"github.com/deluan/navidrome/persistence"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
@@ -22,7 +22,7 @@ var _ = Describe("Players", func() {
 
 	BeforeEach(func() {
 		repo = &mockPlayerRepository{}
-		ds := &persistence.MockDataStore{MockedPlayer: repo, MockedTranscoding: &mockTranscodingRepository{}}
+		ds := &tests.MockDataStore{MockedPlayer: repo, MockedTranscoding: &tests.MockTranscodingRepo{}}
 		players = NewPlayers(ds)
 		beforeRegister = time.Now()
 	})
@@ -35,7 +35,7 @@ var _ = Describe("Players", func() {
 			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
 			Expect(p.Client).To(Equal("client"))
 			Expect(p.UserName).To(Equal("johndoe"))
-			Expect(p.Type).To(Equal("chrome"))
+			Expect(p.UserAgent).To(Equal("chrome"))
 			Expect(repo.lastSaved).To(Equal(p))
 			Expect(trc).To(BeNil())
 		})
@@ -125,7 +125,7 @@ func (m *mockPlayerRepository) Get(id string) (*model.Player, error) {
 	return nil, model.ErrNotFound
 }
 
-func (m *mockPlayerRepository) FindByName(client, userName string) (*model.Player, error) {
+func (m *mockPlayerRepository) FindMatch(userName, client, typ string) (*model.Player, error) {
 	for _, p := range m.data {
 		if p.Client == client && p.UserName == userName {
 			return &p, nil

core/scrobbler/buffered_scrobbler.go

@@ -0,0 +1,115 @@
+package scrobbler
+
+import (
+	"context"
+	"time"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+func newBufferedScrobbler(ds model.DataStore, s Scrobbler, service string) *bufferedScrobbler {
+	b := &bufferedScrobbler{ds: ds, wrapped: s, service: service}
+	b.wakeSignal = make(chan struct{}, 1)
+	go b.run()
+	return b
+}
+
+type bufferedScrobbler struct {
+	ds         model.DataStore
+	wrapped    Scrobbler
+	service    string
+	wakeSignal chan struct{}
+}
+
+func (b *bufferedScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
+	return b.wrapped.IsAuthorized(ctx, userId)
+}
+
+func (b *bufferedScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
+	return b.wrapped.NowPlaying(ctx, userId, track)
+}
+
+func (b *bufferedScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
+	err := b.ds.ScrobbleBuffer(ctx).Enqueue(b.service, userId, s.ID, s.TimeStamp)
+	if err != nil {
+		return err
+	}
+
+	b.sendWakeSignal()
+	return nil
+}
+
+func (b *bufferedScrobbler) sendWakeSignal() {
+	// Don't block if the previous signal was not read yet
+	select {
+	case b.wakeSignal <- struct{}{}:
+	default:
+	}
+}
+
+func (b *bufferedScrobbler) run() {
+	ctx := context.Background()
+	for {
+		if !b.processQueue(ctx) {
+			time.AfterFunc(5*time.Second, func() {
+				b.sendWakeSignal()
+			})
+		}
+		<-b.wakeSignal
+	}
+}
+
+func (b *bufferedScrobbler) processQueue(ctx context.Context) bool {
+	buffer := b.ds.ScrobbleBuffer(ctx)
+	userIds, err := buffer.UserIDs(b.service)
+	if err != nil {
+		log.Error(ctx, "Error retrieving userIds from scrobble buffer", "scrobbler", b.service, err)
+		return false
+	}
+	result := true
+	for _, userId := range userIds {
+		if !b.processUserQueue(ctx, userId) {
+			result = false
+		}
+	}
+	return result
+}
+
+func (b *bufferedScrobbler) processUserQueue(ctx context.Context, userId string) bool {
+	buffer := b.ds.ScrobbleBuffer(ctx)
+	for {
+		entry, err := buffer.Next(b.service, userId)
+		if err != nil {
+			log.Error(ctx, "Error reading from scrobble buffer", "scrobbler", b.service, err)
+			return false
+		}
+		if entry == nil {
+			return true
+		}
+		log.Debug(ctx, "Sending scrobble", "scrobbler", b.service, "track", entry.Title, "artist", entry.Artist)
+		err = b.wrapped.Scrobble(ctx, entry.UserID, Scrobble{
+			MediaFile: entry.MediaFile,
+			TimeStamp: entry.PlayTime,
+		})
+		if err != nil {
+			switch err {
+			case ErrRetryLater:
+				log.Warn(ctx, "Could not send scrobble. Will be retried", "userId", entry.UserID,
+					"track", entry.Title, "artist", entry.Artist, "scrobbler", b.service, err)
+				return false
+			default:
+				log.Error(ctx, "Error sending scrobble to service. Discarding", "scrobbler", b.service,
+					"userId", entry.UserID, "artist", entry.Artist, "track", entry.Title, err)
+			}
+		}
+		err = buffer.Dequeue(entry)
+		if err != nil {
+			log.Error(ctx, "Error removing entry from scrobble buffer", "userId", entry.UserID,
+				"track", entry.Title, "artist", entry.Artist, "scrobbler", b.service, err)
+			return false
+		}
+	}
+}
+
+var _ Scrobbler = (*bufferedScrobbler)(nil)

core/scrobbler/interfaces.go

@@ -0,0 +1,28 @@
+package scrobbler
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+type Scrobble struct {
+	model.MediaFile
+	TimeStamp time.Time
+}
+
+var (
+	ErrNotAuthorized = errors.New("not authorized")
+	ErrRetryLater    = errors.New("retry later")
+	ErrUnrecoverable = errors.New("unrecoverable")
+)
+
+type Scrobbler interface {
+	IsAuthorized(ctx context.Context, userId string) bool
+	NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error
+	Scrobble(ctx context.Context, userId string, s Scrobble) error
+}
+
+type Constructor func(ds model.DataStore) Scrobbler

core/scrobbler/play_tracker.go

@@ -0,0 +1,195 @@
+package scrobbler
+
+import (
+	"context"
+	"sort"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+
+	"github.com/ReneKroon/ttlcache/v2"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/utils/singleton"
+)
+
+const nowPlayingExpire = 60 * time.Minute
+
+type NowPlayingInfo struct {
+	TrackID    string
+	Start      time.Time
+	Username   string
+	PlayerId   string
+	PlayerName string
+}
+
+type Submission struct {
+	TrackID   string
+	Timestamp time.Time
+}
+
+type PlayTracker interface {
+	NowPlaying(ctx context.Context, playerId string, playerName string, trackId string) error
+	GetNowPlaying(ctx context.Context) ([]NowPlayingInfo, error)
+	Submit(ctx context.Context, submissions []Submission) error
+}
+
+type playTracker struct {
+	ds         model.DataStore
+	broker     events.Broker
+	playMap    *ttlcache.Cache
+	scrobblers map[string]Scrobbler
+}
+
+func GetPlayTracker(ds model.DataStore, broker events.Broker) PlayTracker {
+	instance := singleton.Get(playTracker{}, func() interface{} {
+		m := ttlcache.NewCache()
+		m.SkipTTLExtensionOnHit(true)
+		_ = m.SetTTL(nowPlayingExpire)
+		p := &playTracker{ds: ds, playMap: m, broker: broker}
+		p.scrobblers = make(map[string]Scrobbler)
+		for name, constructor := range constructors {
+			s := constructor(ds)
+			if conf.Server.DevEnableBufferedScrobble {
+				s = newBufferedScrobbler(ds, s, name)
+			}
+			p.scrobblers[name] = s
+		}
+		return p
+	})
+	return instance.(*playTracker)
+}
+
+func (p *playTracker) NowPlaying(ctx context.Context, playerId string, playerName string, trackId string) error {
+	user, _ := request.UserFrom(ctx)
+	info := NowPlayingInfo{
+		TrackID:    trackId,
+		Start:      time.Now(),
+		Username:   user.UserName,
+		PlayerId:   playerId,
+		PlayerName: playerName,
+	}
+	_ = p.playMap.Set(playerId, info)
+	player, _ := request.PlayerFrom(ctx)
+	if player.ScrobbleEnabled {
+		p.dispatchNowPlaying(ctx, user.ID, trackId)
+	}
+	return nil
+}
+
+func (p *playTracker) dispatchNowPlaying(ctx context.Context, userId string, trackId string) {
+	t, err := p.ds.MediaFile(ctx).Get(trackId)
+	if err != nil {
+		log.Error(ctx, "Error retrieving mediaFile", "id", trackId, err)
+		return
+	}
+	// TODO Parallelize
+	for name, s := range p.scrobblers {
+		if !s.IsAuthorized(ctx, userId) {
+			continue
+		}
+		log.Debug(ctx, "Sending NowPlaying update", "scrobbler", name, "track", t.Title, "artist", t.Artist)
+		err := s.NowPlaying(ctx, userId, t)
+		if err != nil {
+			log.Error(ctx, "Error sending NowPlayingInfo", "scrobbler", name, "track", t.Title, "artist", t.Artist, err)
+			return
+		}
+	}
+}
+
+func (p *playTracker) GetNowPlaying(ctx context.Context) ([]NowPlayingInfo, error) {
+	var res []NowPlayingInfo
+	for _, playerId := range p.playMap.GetKeys() {
+		value, err := p.playMap.Get(playerId)
+		if err != nil {
+			continue
+		}
+		info := value.(NowPlayingInfo)
+		res = append(res, info)
+	}
+	sort.Slice(res, func(i, j int) bool {
+		return res[i].Start.After(res[j].Start)
+	})
+	return res, nil
+}
+
+func (p *playTracker) Submit(ctx context.Context, submissions []Submission) error {
+	username, _ := request.UsernameFrom(ctx)
+	player, _ := request.PlayerFrom(ctx)
+	if !player.ScrobbleEnabled {
+		log.Debug(ctx, "External scrobbling disabled for this player", "player", player.Name, "ip", player.IPAddress, "user", username)
+	}
+	event := &events.RefreshResource{}
+	success := 0
+
+	for _, s := range submissions {
+		mf, err := p.ds.MediaFile(ctx).Get(s.TrackID)
+		if err != nil {
+			log.Error("Cannot find track for scrobbling", "id", s.TrackID, "user", username, err)
+			continue
+		}
+		err = p.incPlay(ctx, mf, s.Timestamp)
+		if err != nil {
+			log.Error("Error updating play counts", "id", mf.ID, "track", mf.Title, "user", username, err)
+		} else {
+			success++
+			event.With("song", mf.ID).With("album", mf.AlbumID).With("artist", mf.AlbumArtistID)
+			log.Info("Scrobbled", "title", mf.Title, "artist", mf.Artist, "user", username)
+			if player.ScrobbleEnabled {
+				_ = p.dispatchScrobble(ctx, mf, s.Timestamp)
+			}
+		}
+	}
+
+	if success > 0 {
+		p.broker.SendMessage(ctx, event)
+	}
+	return nil
+}
+
+func (p *playTracker) incPlay(ctx context.Context, track *model.MediaFile, timestamp time.Time) error {
+	return p.ds.WithTx(func(tx model.DataStore) error {
+		err := p.ds.MediaFile(ctx).IncPlayCount(track.ID, timestamp)
+		if err != nil {
+			return err
+		}
+		err = p.ds.Album(ctx).IncPlayCount(track.AlbumID, timestamp)
+		if err != nil {
+			return err
+		}
+		err = p.ds.Artist(ctx).IncPlayCount(track.ArtistID, timestamp)
+		return err
+	})
+}
+
+func (p *playTracker) dispatchScrobble(ctx context.Context, t *model.MediaFile, playTime time.Time) error {
+	u, _ := request.UserFrom(ctx)
+	scrobble := Scrobble{MediaFile: *t, TimeStamp: playTime}
+	for name, s := range p.scrobblers {
+		if !s.IsAuthorized(ctx, u.ID) {
+			continue
+		}
+		if conf.Server.DevEnableBufferedScrobble {
+			log.Debug(ctx, "Buffering scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist)
+		} else {
+			log.Debug(ctx, "Sending scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist)
+		}
+		err := s.Scrobble(ctx, u.ID, scrobble)
+		if err != nil {
+			log.Error(ctx, "Error sending Scrobble", "scrobbler", name, "track", t.Title, "artist", t.Artist, err)
+			return err
+		}
+	}
+	return nil
+}
+
+var constructors map[string]Constructor
+
+func Register(name string, init Constructor) {
+	if constructors == nil {
+		constructors = make(map[string]Constructor)
+	}
+	constructors[name] = init
+}

core/scrobbler/play_tracker_test.go

@@ -0,0 +1,207 @@
+package scrobbler
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/navidrome/navidrome/conf"
+
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+	"github.com/navidrome/navidrome/server/events"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("PlayTracker", func() {
+	var ctx context.Context
+	var ds model.DataStore
+	var tracker PlayTracker
+	var track model.MediaFile
+	var album model.Album
+	var artist model.Artist
+	var fake fakeScrobbler
+
+	BeforeEach(func() {
+		// Remove buffering to simplify tests
+		conf.Server.DevEnableBufferedScrobble = false
+
+		ctx = context.Background()
+		ctx = request.WithUser(ctx, model.User{ID: "u-1"})
+		ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: true})
+		ds = &tests.MockDataStore{}
+		fake = fakeScrobbler{Authorized: true}
+		Register("fake", func(ds model.DataStore) Scrobbler {
+			return &fake
+		})
+		tracker = GetPlayTracker(ds, events.GetBroker())
+
+		track = model.MediaFile{
+			ID:          "123",
+			Title:       "Track Title",
+			Album:       "Track Album",
+			AlbumID:     "al-1",
+			Artist:      "Track Artist",
+			ArtistID:    "ar-1",
+			AlbumArtist: "Track AlbumArtist",
+			TrackNumber: 1,
+			Duration:    180,
+			MbzTrackID:  "mbz-123",
+		}
+		_ = ds.MediaFile(ctx).Put(&track)
+		artist = model.Artist{ID: "ar-1"}
+		_ = ds.Artist(ctx).Put(&artist)
+		album = model.Album{ID: "al-1"}
+		_ = ds.Album(ctx).(*tests.MockAlbumRepo).Put(&album)
+	})
+
+	Describe("NowPlaying", func() {
+		It("sends track to agent", func() {
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.NowPlayingCalled).To(BeTrue())
+			Expect(fake.UserID).To(Equal("u-1"))
+			Expect(fake.Track.ID).To(Equal("123"))
+		})
+		It("does not send track to agent if user has not authorized", func() {
+			fake.Authorized = false
+
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123")
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.NowPlayingCalled).To(BeFalse())
+		})
+		It("does not send track to agent if player is not enabled to send scrobbles", func() {
+			ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: false})
+
+			err := tracker.NowPlaying(ctx, "player-1", "player-one", "123")
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.NowPlayingCalled).To(BeFalse())
+		})
+	})
+
+	Describe("GetNowPlaying", func() {
+		BeforeEach(func() {
+			ctx = context.Background()
+		})
+		It("returns current playing music", func() {
+			track2 := track
+			track2.ID = "456"
+			_ = ds.MediaFile(ctx).Put(&track)
+			ctx = request.WithUser(ctx, model.User{UserName: "user-1"})
+			_ = tracker.NowPlaying(ctx, "player-1", "player-one", "123")
+			ctx = request.WithUser(ctx, model.User{UserName: "user-2"})
+			_ = tracker.NowPlaying(ctx, "player-2", "player-two", "456")
+
+			playing, err := tracker.GetNowPlaying(ctx)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(playing).To(HaveLen(2))
+			Expect(playing[0].PlayerId).To(Equal("player-2"))
+			Expect(playing[0].PlayerName).To(Equal("player-two"))
+			Expect(playing[0].Username).To(Equal("user-2"))
+			Expect(playing[0].TrackID).To(Equal("456"))
+
+			Expect(playing[1].PlayerId).To(Equal("player-1"))
+			Expect(playing[1].PlayerName).To(Equal("player-one"))
+			Expect(playing[1].Username).To(Equal("user-1"))
+			Expect(playing[1].TrackID).To(Equal("123"))
+		})
+	})
+
+	Describe("Submit", func() {
+		It("sends track to agent", func() {
+			ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
+			ts := time.Now()
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled).To(BeTrue())
+			Expect(fake.UserID).To(Equal("u-1"))
+			Expect(fake.LastScrobble.ID).To(Equal("123"))
+		})
+
+		It("increments play counts in the DB", func() {
+			ctx = request.WithUser(ctx, model.User{ID: "u-1", UserName: "user-1"})
+			ts := time.Now()
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: ts}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(track.PlayCount).To(Equal(int64(1)))
+			Expect(album.PlayCount).To(Equal(int64(1)))
+			Expect(artist.PlayCount).To(Equal(int64(1)))
+		})
+
+		It("does not send track to agent if user has not authorized", func() {
+			fake.Authorized = false
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled).To(BeFalse())
+		})
+
+		It("does not send track to agent player is not enabled to send scrobbles", func() {
+			ctx = request.WithPlayer(ctx, model.Player{ScrobbleEnabled: false})
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled).To(BeFalse())
+		})
+
+		It("increments play counts even if it cannot scrobble", func() {
+			fake.Error = errors.New("error")
+
+			err := tracker.Submit(ctx, []Submission{{TrackID: "123", Timestamp: time.Now()}})
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(fake.ScrobbleCalled).To(BeFalse())
+
+			Expect(track.PlayCount).To(Equal(int64(1)))
+			Expect(album.PlayCount).To(Equal(int64(1)))
+			Expect(artist.PlayCount).To(Equal(int64(1)))
+		})
+
+	})
+
+})
+
+type fakeScrobbler struct {
+	Authorized       bool
+	NowPlayingCalled bool
+	ScrobbleCalled   bool
+	UserID           string
+	Track            *model.MediaFile
+	LastScrobble     Scrobble
+	Error            error
+}
+
+func (f *fakeScrobbler) IsAuthorized(ctx context.Context, userId string) bool {
+	return f.Error == nil && f.Authorized
+}
+
+func (f *fakeScrobbler) NowPlaying(ctx context.Context, userId string, track *model.MediaFile) error {
+	f.NowPlayingCalled = true
+	if f.Error != nil {
+		return f.Error
+	}
+	f.UserID = userId
+	f.Track = track
+	return nil
+}
+
+func (f *fakeScrobbler) Scrobble(ctx context.Context, userId string, s Scrobble) error {
+	f.ScrobbleCalled = true
+	if f.Error != nil {
+		return f.Error
+	}
+	f.UserID = userId
+	f.LastScrobble = s
+	return nil
+}

core/scrobbler/scrobbler_suite_test.go

@@ -0,0 +1,17 @@
+package scrobbler
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestAgents(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Scrobbler Test Suite")
+}

core/share.go

@@ -0,0 +1,54 @@
+package core
+
+import (
+	"context"
+
+	"github.com/deluan/rest"
+	gonanoid "github.com/matoous/go-nanoid"
+	"github.com/navidrome/navidrome/model"
+)
+
+type Share interface {
+	NewRepository(ctx context.Context) rest.Repository
+}
+
+func NewShare(ds model.DataStore) Share {
+	return &shareService{
+		ds: ds,
+	}
+}
+
+type shareService struct {
+	ds model.DataStore
+}
+
+func (s *shareService) NewRepository(ctx context.Context) rest.Repository {
+	repo := s.ds.Share(ctx)
+	wrapper := &shareRepositoryWrapper{
+		ShareRepository: repo,
+		Repository:      repo.(rest.Repository),
+		Persistable:     repo.(rest.Persistable),
+	}
+	return wrapper
+}
+
+type shareRepositoryWrapper struct {
+	model.ShareRepository
+	rest.Repository
+	rest.Persistable
+}
+
+func (r *shareRepositoryWrapper) Save(entity interface{}) (string, error) {
+	s := entity.(*model.Share)
+	id, err := gonanoid.Generate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 9)
+	if err != nil {
+		return "", err
+	}
+	s.Name = id
+	id, err = r.Persistable.Save(s)
+	return id, err
+}
+
+func (r *shareRepositoryWrapper) Update(entity interface{}, _ ...string) error {
+	return r.Persistable.Update(entity, "description")
+}

core/share_test.go

@@ -0,0 +1,51 @@
+package core
+
+import (
+	"context"
+
+	"github.com/deluan/rest"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Share", func() {
+	var ds model.DataStore
+	var share Share
+	var mockedRepo rest.Persistable
+
+	BeforeEach(func() {
+		ds = &tests.MockDataStore{}
+		mockedRepo = ds.Share(context.Background()).(rest.Persistable)
+		share = NewShare(ds)
+	})
+
+	Describe("NewRepository", func() {
+		var repo rest.Persistable
+
+		BeforeEach(func() {
+			repo = share.NewRepository(context.Background()).(rest.Persistable)
+		})
+
+		Describe("Save", func() {
+			It("it adds a random name", func() {
+				entity := &model.Share{Description: "test"}
+				id, err := repo.Save(entity)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(id).ToNot(BeEmpty())
+				Expect(entity.Name).ToNot(BeEmpty())
+			})
+		})
+
+		Describe("Update", func() {
+			It("filters out read-only fields", func() {
+				entity := "entity"
+				err := repo.Update(entity)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(mockedRepo.(*tests.MockShareRepo).Entity).To(Equal("entity"))
+				Expect(mockedRepo.(*tests.MockShareRepo).Cols).To(ConsistOf("description"))
+			})
+		})
+	})
+})

core/transcoder/transcoder.go

@@ -8,7 +8,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/deluan/navidrome/log"
+	"github.com/navidrome/navidrome/log"
 )
 
 type Transcoder interface {
@@ -16,20 +16,15 @@ type Transcoder interface {
 }
 
 func New() Transcoder {
-	path, err := exec.LookPath("ffmpeg")
-	if err != nil {
-		log.Error("Unable to find ffmpeg", err)
-	}
-	log.Debug("Found ffmpeg", "path", path)
-	return &ffmpeg{}
+	return &externalTranscoder{}
 }
 
-type ffmpeg struct{}
+type externalTranscoder struct{}
 
-func (ff *ffmpeg) Start(ctx context.Context, command, path string, maxBitRate int) (f io.ReadCloser, err error) {
+func (e *externalTranscoder) Start(ctx context.Context, command, path string, maxBitRate int) (f io.ReadCloser, err error) {
 	args := createTranscodeCommand(command, path, maxBitRate)
 
-	log.Trace(ctx, "Executing ffmpeg command", "cmd", args)
+	log.Trace(ctx, "Executing transcoding command", "cmd", args)
 	cmd := exec.Command(args[0], args[1:]...) // #nosec
 	cmd.Stderr = os.Stderr
 	if f, err = cmd.StdoutPipe(); err != nil {
@@ -48,8 +43,8 @@ func (ff *ffmpeg) Start(ctx context.Context, command, path string, maxBitRate in
 func createTranscodeCommand(cmd, path string, maxBitRate int) []string {
 	split := strings.Split(cmd, " ")
 	for i, s := range split {
-		s = strings.Replace(s, "%s", path, -1)
-		s = strings.Replace(s, "%b", strconv.Itoa(maxBitRate), -1)
+		s = strings.ReplaceAll(s, "%s", path)
+		s = strings.ReplaceAll(s, "%b", strconv.Itoa(maxBitRate))
 		split[i] = s
 	}
 

core/transcoder/transcoder_test.go

@@ -3,8 +3,8 @@ package transcoder
 import (
 	"testing"
 
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/tests"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )

core/wire_providers.go

@@ -1,15 +1,23 @@
 package core
 
 import (
-	"github.com/deluan/navidrome/core/transcoder"
 	"github.com/google/wire"
+	"github.com/navidrome/navidrome/core/agents"
+	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/core/transcoder"
 )
 
 var Set = wire.NewSet(
 	NewArtwork,
 	NewMediaStreamer,
-	NewTranscodingCache,
-	NewImageCache,
+	GetTranscodingCache,
+	GetImageCache,
 	NewArchiver,
+	NewExternalMetadata,
+	NewCacheWarmer,
+	NewPlayers,
+	agents.New,
 	transcoder.New,
+	scrobbler.GetPlayTracker,
+	NewShare,
 )

db/db.go

@@ -2,13 +2,14 @@ package db
 
 import (
 	"database/sql"
+	"fmt"
 	"os"
-	"sync"
 
-	"github.com/deluan/navidrome/conf"
-	_ "github.com/deluan/navidrome/db/migrations"
-	"github.com/deluan/navidrome/log"
 	_ "github.com/mattn/go-sqlite3"
+	"github.com/navidrome/navidrome/conf"
+	_ "github.com/navidrome/navidrome/db/migration"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/utils/singleton"
 	"github.com/pressly/goose"
 )
 
@@ -17,26 +18,21 @@ var (
 	Path   string
 )
 
-var (
-	once sync.Once
-	db   *sql.DB
-)
-
 func Db() *sql.DB {
-	once.Do(func() {
-		var err error
+	instance := singleton.Get(&sql.DB{}, func() interface{} {
 		Path = conf.Server.DbPath
 		if Path == ":memory:" {
 			Path = "file::memory:?cache=shared&_foreign_keys=on"
 			conf.Server.DbPath = Path
 		}
 		log.Debug("Opening DataBase", "dbPath", Path, "driver", Driver)
-		db, err = sql.Open(Driver, Path)
+		instance, err := sql.Open(Driver, Path)
 		if err != nil {
 			panic(err)
 		}
+		return instance
 	})
-	return db
+	return instance.(*sql.DB)
 }
 
 func EnsureLatestVersion() {
@@ -54,6 +50,9 @@ func EnsureLatestVersion() {
 		log.Error("Error disabling foreign_keys", err)
 	}
 
+	gooseLogger := &logAdapter{silent: isSchemaEmpty(db)}
+	goose.SetLogger(gooseLogger)
+
 	err = goose.SetDialect(Driver)
 	if err != nil {
 		log.Error("Invalid DB driver", "driver", Driver, err)
@@ -65,3 +64,45 @@ func EnsureLatestVersion() {
 		os.Exit(1)
 	}
 }
+
+func isSchemaEmpty(db *sql.DB) bool { // nolint:interfacer
+	rows, err := db.Query("SELECT name FROM sqlite_master WHERE type='table' AND name='goose_db_version';") // nolint:rowserrcheck
+	if err != nil {
+		log.Error("Database could not be opened!", err)
+		os.Exit(1)
+	}
+	defer rows.Close()
+	return !rows.Next()
+}
+
+type logAdapter struct {
+	silent bool
+}
+
+func (l *logAdapter) Fatal(v ...interface{}) {
+	log.Error(fmt.Sprint(v...))
+	os.Exit(-1)
+}
+
+func (l *logAdapter) Fatalf(format string, v ...interface{}) {
+	log.Error(fmt.Sprintf(format, v...))
+	os.Exit(-1)
+}
+
+func (l *logAdapter) Print(v ...interface{}) {
+	if !l.silent {
+		log.Info(fmt.Sprint(v...))
+	}
+}
+
+func (l *logAdapter) Println(v ...interface{}) {
+	if !l.silent {
+		log.Info(fmt.Sprintln(v...))
+	}
+}
+
+func (l *logAdapter) Printf(format string, v ...interface{}) {
+	if !l.silent {
+		log.Info(fmt.Sprintf(format, v...))
+	}
+}

db/db_test.go

@@ -0,0 +1,36 @@
+package db
+
+import (
+	"database/sql"
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestDB(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "DB Suite")
+}
+
+var _ = Describe("isSchemaEmpty", func() {
+	var db *sql.DB
+	BeforeEach(func() {
+		path := "file::memory:"
+		db, _ = sql.Open(Driver, path)
+	})
+
+	It("returns false if the goose metadata table is found", func() {
+		_, err := db.Exec("create table goose_db_version (id primary key);")
+		Expect(err).ToNot(HaveOccurred())
+		Expect(isSchemaEmpty(db)).To(BeFalse())
+	})
+
+	It("returns true if the schema is brand new", func() {
+		Expect(isSchemaEmpty(db)).To(BeTrue())
+	})
+})

db/migration/20200130083147_create_schema.go

@@ -3,7 +3,7 @@ package migrations
 import (
 	"database/sql"
 
-	"github.com/deluan/navidrome/log"
+	"github.com/navidrome/navidrome/log"
 	"github.com/pressly/goose"
 )