Fix getTopSongs endpoint

* Disable mobile player cover animation when EnableCoverAnimation is set to false. Also increase cover art size and remove rounded borders.

* Display song album and year in mobile player view

* Remove default singer element from mobile player and reduce vertical white space

* Only add song year if it exists

* Add song year to desktop player when present

* Increase non-animated cover size to 85% and set a limit on the width of 600px.

* Explain what what the styles impact

* Remove unused style for songArtist

* Apply prettier

* Adjust player styles to handle nonsquare album art better. Should probably push this upstream too

* Also fix desktop player's handling of non square cover art.

.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.16",
+			// 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

@@ -1,14 +1,10 @@
 .DS_Store
 ui/node_modules
-ui/build
-Jamstash-master
 Dockerfile
+docker-compose*.yml
 data
 *.db
 testDB
-*_test.go
 navidrome
 navidrome.db
 navidrome.toml
-assets/*gen.go
-dist

.git-blame-ignore-revs

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

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: deluan
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+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
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.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/build.yml

@@ -1,53 +0,0 @@
-name: Build
-on: [push]
-jobs:
-  go:
-    name: Test Server on ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-# TODO Fix tests in Windows
-#        os: [macOS-latest, ubuntu-latest, windows-latest]
-        os: [macOS-latest, ubuntu-latest]
-
-    steps:
-      - name: Set up Go 1.13
-        uses: actions/setup-go@v1
-        with:
-          go-version: 1.13
-        id: go
-
-      - name: Check out code into the Go module directory
-        uses: actions/checkout@v1
-
-      - name: Download dependencies
-        run: go mod download
-
-      - name: Test
-        run: go test -cover ./... -v
-
-  js:
-    name: Test UI
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v1
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 13
-
-      - name: npm install dependencies
-        run: |
-          cd ui
-          npm ci
-
-# TODO: Enable when there are tests to run
-#      - name: npm test
-#        run: |
-#          cd ui
-#          CI=test npm test
-
-      - name: npm build
-        run: |
-          cd ui
-          npm run build

.github/workflows/docker-tags.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+GIT_TAG="${GITHUB_REF##refs/tags/}"
+GIT_BRANCH="${GITHUB_REF##refs/heads/}"
+GIT_SHA=$(git rev-parse --short HEAD)
+PR_NUM=$(jq --raw-output .pull_request.number "$GITHUB_EVENT_PATH")
+
+DOCKER_IMAGE_TAG="--tag ${DOCKER_IMAGE}:sha-${GIT_SHA}"
+
+if [[ $PR_NUM != "null" ]]; then
+  DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:pr-${PR_NUM}"
+fi
+
+if [[ $GITHUB_REF != "$GIT_TAG" ]]; then
+    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:${GIT_TAG#v}  --tag ${DOCKER_IMAGE}:latest"
+elif [[ $GITHUB_REF == "refs/heads/master" ]]; then
+    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:develop"
+elif [[ $GIT_BRANCH = feature/* ]]; then
+    DOCKER_IMAGE_TAG="${DOCKER_IMAGE_TAG} --tag ${DOCKER_IMAGE}:$(echo $GIT_BRANCH | tr / -)"
+fi
+
+echo ${DOCKER_IMAGE_TAG}

.github/workflows/pipeline.dockerfile

@@ -0,0 +1,38 @@
+#####################################################
+### Copy platform specific binary
+FROM bash as copy-binary
+ARG TARGETPLATFORM
+
+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
+RUN chmod +x /navidrome
+
+
+#####################################################
+### Build Final Image
+FROM alpine as release
+LABEL maintainer="deluan@navidrome.org"
+
+# Install ffmpeg and output build config
+RUN apk add --no-cache ffmpeg
+RUN ffmpeg -buildconf
+
+COPY --from=copy-binary /navidrome /app/
+
+VOLUME ["/data", "/music"]
+ENV ND_MUSICFOLDER /music
+ENV ND_DATAFOLDER /data
+ENV ND_PORT 4533
+ENV GODEBUG "asyncpreemptoff=1"
+
+EXPOSE ${ND_PORT}
+HEALTHCHECK CMD wget -O- http://localhost:${ND_PORT}/ping || exit 1
+WORKDIR /app
+
+ENTRYPOINT ["/app/navidrome"]

.github/workflows/pipeline.yml

@@ -0,0 +1,191 @@
+name: Pipeline
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - "v*"
+  pull_request:
+    branches:
+      - master
+jobs:
+  golangci-lint:
+    name: Lint Server
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install taglib
+        run: sudo apt-get install libtag1-dev
+
+      - uses: actions/checkout@v2
+
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v2
+        with:
+          version: v1.40
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          args: --timeout 2m
+
+  go:
+    name: Test Server with Go ${{ matrix.go_version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go_version: [1.16.x]
+    steps:
+      - name: Install taglib
+        run: sudo apt-get install libtag1-dev
+
+      - name: Set up Go ${{ matrix.go_version }}
+        uses: actions/setup-go@v2
+        with:
+          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@v2
+        id: cache-go
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ matrix.go_version }}-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ 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
+        with:
+          node-version: 16
+
+      - uses: actions/cache@v2
+        id: cache-npm
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('ui/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: npm install dependencies
+        run: |
+          cd ui
+          npm ci
+
+      - name: npm lint
+        run: |
+          cd ui
+          npm run check-formatting && npm run lint
+
+      - name: npm test
+        run: |
+          cd ui
+          npm test
+
+      - name: npm build
+        run: |
+          cd ui
+          npm run build
+
+      - uses: actions/upload-artifact@v2
+        with:
+          name: js-bundle
+          path: ui/build
+          retention-days: 7
+
+  binaries:
+    name: Binaries
+    needs: [js, go, golangci-lint]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - uses: actions/download-artifact@v2
+        with:
+          name: js-bundle
+          path: ui/build
+
+      - name: Show Tags
+        run: git tag
+
+      - name: Show Version
+        run: git describe --tags
+
+      - name: Generate .gitinfo
+        run: make .gitinfo
+
+      - name: Run GoReleaser - SNAPSHOT
+        if: startsWith(github.ref, 'refs/tags/') != true
+        uses: docker://deluan/ci-goreleaser:1.16.4-1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: goreleaser release --rm-dist --skip-publish --snapshot
+
+      - name: Run GoReleaser - RELEASE
+        if: startsWith(github.ref, 'refs/tags/')
+        uses: docker://deluan/ci-goreleaser:1.16.4-1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          args: goreleaser release --rm-dist
+
+      - uses: actions/upload-artifact@v2
+        with:
+          name: binaries
+          path: |
+            dist
+            !dist/*.tar.gz
+            !dist/*.zip
+          retention-days: 7
+
+  docker:
+    name: 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: docker/setup-buildx-action@v1
+        if: env.DOCKER_IMAGE != ''
+
+      - uses: actions/checkout@v2
+        if: env.DOCKER_IMAGE != ''
+
+      - uses: actions/download-artifact@v2
+        if: env.DOCKER_IMAGE != ''
+        with:
+          name: binaries
+          path: dist
+
+      - name: Build the Docker image and push
+        if: env.DOCKER_IMAGE != ''
+        env:
+          DOCKER_IMAGE: ${{secrets.DOCKER_IMAGE}}
+          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/release.yml

@@ -1,31 +0,0 @@
-name: Release
-
-on:
-  create:
-    tags:
-      - v*.*.*
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v1
-        with:
-          fetch-depth: 0
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 13
-      - name: Build UI
-        run: |
-          cd ui
-          npm ci
-          npm run build
-      - name: Fetch tags
-        run: git fetch --depth=1 origin +refs/tags/*:refs/tags/*
-      - name: Run GoReleaser
-        uses: docker://bepsays/ci-goreleaser:1.13-4
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          args: goreleaser release --rm-dist

.gitignore

@@ -1,5 +1,6 @@
 .DS_Store
 .idea
+.vscode
 .envrc
 /navidrome
 /iTunes*.xml
@@ -9,12 +10,16 @@ vendor/*/
 wiki
 TODO.md
 var
-Artwork
 navidrome.toml
 master.zip
-Jamstash-master
 testDB
 navidrome.db
 *.swp
-*_gen.go
+embedded_gen.go
 dist
+music
+docker-compose.yml
+navidrome.db-shm
+navidrome.db-wal
+tags
+.gitinfo

.golangci.yml

@@ -0,0 +1,29 @@
+linters:
+  enable:
+    - bodyclose
+    - deadcode
+    - depguard
+    - dogsled
+    - errcheck
+    - gocyclo
+    - goprintffuncname
+    - gosec
+    - gosimple
+    - govet
+    - ineffassign
+    - interfacer
+    - misspell
+    - rowserrcheck
+    - staticcheck
+    - structcheck
+    - typecheck
+    - unconvert
+    - unused
+    - varcheck
+    - whitespace
+
+issues:
+  exclude-rules:
+    - linters:
+        - gosec
+      text: "(G501|G401|G505):"

.goreleaser.yml

@@ -1,27 +1,8 @@
 # GoReleaser config
-
-before:
-  hooks:
-    - go get -u github.com/go-bindata/go-bindata/...
-    - go-bindata -fs -prefix ui/build -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/...
-    - git checkout .
+project_name: navidrome
 
 builds:
-  - id: navidrome_darwin
-    env:
-      - CGO_ENABLED=1
-      - CC=o64-clang
-      - CXX=o64-clang++
-    goos:
-      - darwin
-    goarch:
-      - amd64
-    flags:
-      - -tags=embed
-    ldflags:
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
-
-  - id: navidrome_linux
+  - id: navidrome_linux_amd64
     env:
       - CGO_ENABLED=1
     goos:
@@ -29,60 +10,127 @@ builds:
     goarch:
       - amd64
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
+    ldflags:
+      - "-extldflags '-static -lz'"
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_linux_386
+    env:
+      - CGO_ENABLED=1
+    goos:
+      - linux
+    goarch:
+      - 386
+    flags:
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
-  - id: navidrome_windows_i686
+  - id: navidrome_linux_arm
+    env:
+      - CGO_ENABLED=1
+      - CC=arm-linux-gnueabi-gcc
+      - CXX=arm-linux-gnueabi-g++
+    goos:
+      - linux
+    goarch:
+      - arm
+    goarm:
+      - 5
+      - 6
+      - 7
+    flags:
+      - -tags=embed,netgo
+    ldflags:
+      - "-extldflags '-static'"
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_linux_arm64
+    env:
+      - CGO_ENABLED=1
+      - CC=aarch64-linux-gnu-gcc
+      - CXX=aarch64-linux-gnu-g++
+    goos:
+      - linux
+    goarch:
+      - arm64
+    flags:
+      - -tags=embed,netgo
+    ldflags:
+      - "-extldflags '-static'"
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_windows_386
     env:
       - CGO_ENABLED=1
       - CC=i686-w64-mingw32-gcc
       - CXX=i686-w64-mingw32-g++
+      - PKG_CONFIG_PATH=/mingw32/lib/pkgconfig
     goos:
       - windows
     goarch:
       - 386
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -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
       - CXX=x86_64-w64-mingw32-g++
+      - PKG_CONFIG_PATH=/mingw64/lib/pkgconfig
     goos:
       - windows
     goarch:
       - amd64
     flags:
-      - -tags=embed
+      - -tags=embed,netgo
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_darwin_amd64
+    env:
+      - CGO_ENABLED=1
+      - CC=o64-clang
+      - CXX=o64-clang++
+      - PKG_CONFIG_PATH=/darwin/lib/pkgconfig
+    goos:
+      - darwin
+    goarch:
+      - amd64
+    flags:
+      - -tags=embed,netgo
+    ldflags:
+      - -s -w -X github.com/navidrome/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/navidrome/navidrome/consts.gitTag={{.Version}}
 
 archives:
-  -
-    format_overrides:
+  - format_overrides:
       - goos: windows
         format: zip
+    replacements:
+      darwin: macOS
+      linux: Linux
+      windows: Windows
+      386: i386
+      amd64: x86_64
+
 checksum:
-  name_template: 'checksums.txt'
+  name_template: "{{ .ProjectName }}_checksums.txt"
 
 snapshot:
-  name_template: "{{ .Tag }}-next"
+  name_template: "{{ .Tag }}-SNAPSHOT"
 
 release:
   draft: true
 
 changelog:
-  sort: asc
+  # sort: asc
   filters:
     exclude:
-      - '^docs:'
-      - '^test:'
-      - '^chore:'
-      - '^ci:'
+      - "^docs:"

.nvmrc

@@ -1 +1 @@
-v13.7.0
+v16

API_COMPATIBILITY.md

@@ -1,69 +0,0 @@
-
-###  Supported Subsonic API endpoints
-
-Navidrome is currently compatible with [Subsonic API](http://www.subsonic.org/pages/api.jsp) v1.8.0, with some exceptions.
-
-This is an (almost) up to date list of all Subsonic API endpoints implemented by Navidrome. 
-Check the "Notes" column for limitations/missing behaviour. Also keep in mind these differences between 
-Navidrome and Subsonic:
-
-* Right now, Navidrome only works with a single Music Library (Music Folder)
-* Navidrome does not mark songs as played by calls to `stream`, only when 
- `scrobble` is called with `submission=true`
-* Next features to be implemented: Playlists (WIP), MultiUser (WIP), Jukebox, Sharing, Podcasts, Bookmarks, Internet Radio. 
-
-Navidrome is actively being tested with:
-[DSub](http://www.subsonic.org/pages/apps.jsp#dsub),
-[Music Stash](https://play.google.com/store/apps/details?id=com.ghenry22.mymusicstash) and
-[Jamstash](http://www.subsonic.org/pages/apps.jsp#jamstash))
-
-
-| ENDPOINT               | NOTES |
-|------------------------|-------|
-| _SYSTEM_               ||
-| `ping`                 | |
-| `getLicense`           | Always valid ;) |    
-| ||
-| _BROWSING_             ||
-| `getMusicFolders`      | Hardcoded to just one, configured in `app.conf` |
-| `getIndexes`           | Doesn't support shortcuts, nor direct children |
-| `getMusicDirectory`    | |
-| `getSong`              | |
-| `getArtists`           | |
-| `getArtist`            | |
-| `getAlbum`             | |
-| `getGenres`            | |
-| ||
-| _ALBUM/SONGS LISTS_    ||
-| `getAlbumList`         | `byYear` and `byGenre` are not implemented |
-| `getAlbumList2`        | `byYear` and `byGenre` are not implemented |
-| `getStarred`           | |
-| `getStarred2`          | |
-| `getNowPlaying`        | |
-| `getRandomSongs`       | Ignores `year` parameter |
-| ||
-| _SEARCHING_            ||
-| `search2`              | Doesn't support Lucene queries, only simple auto complete queries |
-| `search3`              | Doesn't support Lucene queries, only simple auto complete queries |
-| ||
-| _PLAYLISTS_            ||
-| `getPlaylists`         | `username` parameter is not implemented |
-| `getPlaylist`          | |
-| `createPlaylist`       | Return empty response on success |
-| `updatePlaylist`       | `comment` and `public` are not implemented. All playlists are public |
-| `deletePlaylist`       | |
-| ||
-| _MEDIA RETRIEVAL_      ||
-| `stream`               | Returns wrong content-length when downsampling |
-| `download`             | |
-| `getCoverArt`          | Only gets embedded artwork |
-| `getAvatar`            | Always returns the same image |
-| ||
-| _MEDIA ANNOTATION_     ||
-| `star`                 | |
-| `unstar`               | |
-| `setRating`            | Doesn't work with artists |
-| `scrobble`             | No Last.FM support yet. It is used to update play count and last played |
-| ||
-| _USER MANAGEMENT_      ||
-| `getUser`              | Hardcoded all roles, ignores `username` parameter|

CODE_OF_CONDUCT.md

@@ -0,0 +1,129 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+navidrome@navidrome.org.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

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)
+
+```

Dockerfile

@@ -1,67 +0,0 @@
-#####################################################
-### Build UI bundles
-FROM node:13.7-alpine AS jsbuilder
-WORKDIR /src
-COPY ui/package.json ui/package-lock.json ./
-RUN npm ci
-COPY ui/ .
-RUN npm run build
-
-
-#####################################################
-### Build executable
-FROM golang:1.13-alpine AS gobuilder
-
-# Download build tools
-RUN mkdir -p /src/ui/build
-RUN apk add -U --no-cache build-base git
-RUN go get -u github.com/go-bindata/go-bindata/...
-
-# Download and unpack static ffmpeg
-ARG FFMPEG_URL=https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz
-RUN wget -O /tmp/ffmpeg.tar.xz ${FFMPEG_URL}
-RUN cd /tmp && tar xJf ffmpeg.tar.xz && rm ffmpeg.tar.xz
-
-# Download project dependencies
-WORKDIR /src
-COPY go.mod go.sum ./
-RUN go mod download
-
-# Copy source, test it
-COPY . .
-RUN go test ./...
-
-# Copy UI bundle, build executable
-COPY --from=jsbuilder /src/build/* /src/ui/build/
-COPY --from=jsbuilder /src/build/static/css/* /src/ui/build/static/css/
-COPY --from=jsbuilder /src/build/static/js/* /src/ui/build/static/js/
-RUN rm -rf /src/build/css /src/build/js
-RUN GIT_TAG=$(git name-rev --name-only HEAD) && \
-    GIT_TAG=${GIT_TAG#"tags/"} && \
-    GIT_SHA=$(git rev-parse --short HEAD) && \
-    echo "Building version: ${GIT_TAG} (${GIT_SHA})" && \
-    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}" -tags=embed
-
-#####################################################
-### Build Final Image
-FROM alpine as release
-MAINTAINER  Deluan Quintao <navidrome@deluan.com>
-
-COPY --from=gobuilder /src/navidrome /app/
-COPY --from=gobuilder /tmp/ffmpeg*/ffmpeg /usr/bin/
-
-# Check if ffmpeg runs properly
-RUN ffmpeg -buildconf
-
-VOLUME ["/data", "/music"]
-ENV ND_MUSICFOLDER /music
-ENV ND_DATAFOLDER /data
-ENV ND_SCANINTERVAL 1m
-ENV ND_LOGLEVEL info
-ENV ND_PORT 4533
-
-EXPOSE 4533
-WORKDIR /app
-
-ENTRYPOINT "/app/navidrome"

Makefile

@@ -1,88 +1,153 @@
-GO_VERSION=1.13
-NODE_VERSION=v13.7.0
+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 ifneq ("$(wildcard .gitinfo)","")
+include .gitinfo
+endif
 
-.PHONY: dev
-dev: check_env
-	@goreman -f Procfile.dev -b 4533 start
+CI_RELEASER_VERSION=1.16.4-1 ## https://github.com/navidrome/ci-goreleaser
 
-.PHONY: server
-server: check_go_env
-	@reflex -d none -c reflex.conf
-
-.PHONY: watch
-watch: check_go_env
-	ginkgo watch -notify ./...
-
-.PHONY: test
-test: check_go_env
-	go test ./... -v
-#	@(cd ./ui && npm test -- --watchAll=false)
-
-.PHONY: testall
-testall: check_go_env test
-	@(cd ./ui && npm test -- --watchAll=false)
-
-.PHONY: setup
-setup: Jamstash-master
-	@which goconvey   || (echo "Installing GoConvey" && GO111MODULE=off go get -u github.com/smartystreets/goconvey)
-	@which wire       || (echo "Installing Wire"     && GO111MODULE=off go get -u github.com/google/wire/cmd/wire)
-	@which go-bindata || (echo "Installing BinData"  && GO111MODULE=off go get -u github.com/go-bindata/go-bindata/...)
-	@which reflex     || (echo "Installing Reflex"   && GO111MODULE=off go get -u github.com/cespare/reflex)
-	@which goreman    || (echo "Installing Goreman"  && GO111MODULE=off go get -u github.com/mattn/goreman)
-	@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)
-	go mod download
+setup: check_env download-deps ##@1_Run_First Install dependencies and prepare development environment
+	@echo Downloading Node dependencies...
 	@(cd ./ui && npm ci)
+.PHONY: setup
 
-.PHONY: static
-static:
-	cd static && go-bindata -fs -prefix "static" -nocompress -ignore="\\\*.go" -pkg static .
+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
 
-Jamstash-master:
-	wget -N https://github.com/tsquillario/Jamstash/archive/master.zip
-	unzip -o master.zip
-	rm master.zip
+server: check_go_env  ##@Development Start the backend in development mode
+	@go run github.com/cespare/reflex -d none -c reflex.conf
+.PHONY: server
 
-.PHONE: check_env
-check_env: check_go_env check_node_env
+watch: ##@Development Start Go tests in watch mode (re-run when code changes)
+	go run github.com/onsi/ginkgo/ginkgo watch -notify ./...
+.PHONY: watch
 
-.PHONY: check_go_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\n"; exit 1)
+test: ##@Development Run Go tests
+	go test ./...
+.PHONY: test
 
-.PHONY: check_node_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)
+testall: test ##@Development Run Go and JS tests
+	@(cd ./ui && npm test -- --watchAll=false)
+.PHONY: testall
 
-UI_SRC = $(shell find ui/src ui/public -name "*.js")
-ui/build: $(UI_SRC) $(UI_PUBLIC) ui/package-lock.json
-	@(cd ./ui && npm run build)
+lint: ##@Development Lint Go code
+	go run github.com/golangci/golangci-lint/cmd/golangci-lint run -v --timeout 5m
+.PHONY: lint
 
-assets/embedded_gen.go: ui/build
-	go-bindata -fs -prefix "ui/build" -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/...
+lintall: lint ##@Development Lint Go and JS code
+	@(cd ./ui && npm run check-formatting && npm run lint)
+.PHONY: lintall
 
-.PHONY: build
-build: check_go_env
-	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=master"
+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: ##@Development Setup Git hooks (pre-commit and pre-push)
+	@echo Setting up git hooks
+	@mkdir -p .git/hooks
+	@(cd .git/hooks && ln -sf ../../git/* .)
+.PHONY: setup-git
+
+buildall: buildjs build ##@Build Build the project, both frontend and backend
 .PHONY: buildall
-buildall: check_env assets/embedded_gen.go
-	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=master" -tags=embed
 
-.PHONY: release
+build: check_go_env  ##@Build Build only backend
+	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
+
+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
+	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
+	@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
+
+.gitinfo:
+	@echo "export GIT_SHA=${GIT_SHA}" > .gitinfo
+	@echo "export GIT_TAG=${GIT_TAG}" >> .gitinfo
+.PHONY: .gitinfo
+
 release:
 	@if [[ ! "${V}" =~ ^[0-9]+\.[0-9]+\.[0-9]+.*$$ ]]; then echo "Usage: make release V=X.X.X"; exit 1; fi
 	go mod tidy
-	make test
 	@if [ -n "`git status -s`" ]; then echo "\n\nThere are pending changes. Please commit or stash first"; exit 1; fi
+	make pre-push
 	git tag v${V}
-	git push origin v${V}
-	git push origin master
+	git push origin v${V} --no-verify
+.PHONY: release
 
-.PHONY: dist
-dist:
-	 docker run -it -v $(PWD):/github/workspace -w /github/workspace bepsays/ci-goreleaser:1.13-4 goreleaser release --rm-dist --skip-publish --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,128 +1,63 @@
-# Navidrome Music Streamer
+# Navidrome Music Server
 
-[![Build](https://img.shields.io/github/workflow/status/deluan/navidrome/Build?style=for-the-badge)](https://github.com/deluan/navidrome/actions)
-[![Last Release](https://img.shields.io/github/v/release/deluan/navidrome?label=latest&style=for-the-badge)](https://github.com/deluan/navidrome/releases)
-[![Docker Pulls](https://img.shields.io/docker/pulls/deluan/navidrome?style=for-the-badge)](https://hub.docker.com/r/deluan/navidrome)
+[![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://github.com/navidrome/navidrome/actions)
+[![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/)
 
 Navidrome is an open source web-based music collection server and streamer. It gives you freedom to listen to your 
-music collection from any browser or mobile device.
-
-This is a fully functional _alpha quality_ software. Expect some changes in the feature set and the way it works. 
+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 fill a [GitHub issue](https://github.com/deluan/navidrome/issues) or join the chat in our [Discord server](https://discord.gg/xh7j7yF)
-
-
-## Features
-
-- Handles very large music collections
-- Streams virtually any audio format available
-- Reads and uses all your beautifully curated metadata (id3 tags)
-- Multi-user, each user has their own play counts, playlists, favourites, etc..
-- Very low resource usage: Ex: with a library of 300GB (~29000 songs), it uses less than 50MB of RAM
-- Multi-platform, runs on macOS, Linux and Windows. Docker images are also provided
-- Automatically monitors your library for changes, importing new files and reloading new metadata 
-- Modern and responsive Web interface based on Material UI, to manage users and browse your library
-- Compatible with the huge selection of clients for [Subsonic](http://www.subsonic.org), 
-   [Airsonic](https://airsonic.github.io/) and [Madsonic](https://www.madsonic.org/). 
-   See the [complete list of available mobile and web apps](https://airsonic.github.io/docs/apps/)
-
-## Road map
-
-This project is being actively worked on. Expect a more polished experience and new features/releases 
-on a frequent basis. Some upcoming features planned: 
-
-- Transcoding/Downsampling on-the-fly
-- Last.FM integration
-- Integrated music player
-- Pre-build binaries for Raspberry Pi
-- Smart/dynamic playlists (similar to iTunes)
-- Jukebox mode
-- Sharing links to albums/songs/playlists
-- Podcasts
+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/), 
+[themes](https://www.navidrome.org/docs/developers/creating-themes)), please join the chat in our 
+[Discord server](https://discord.gg/xh7j7yF). 
 
 ## Installation
 
-Various options are available:
+See instructions in the [project's website](https://www.navidrome.org/docs/installation/)
 
-### Pre-build executables
+## Features
+ 
+ - Handles very **large music collections**
+ - Streams virtually **any audio format** available
+ - Reads and uses all your beautifully curated **metadata**
+ - Great support for **compilations** (Various Artists albums) and **box sets** (multi-disc albums)
+ - **Multi-user**, each user has their own play counts, playlists, favourites, etc...
+ - Very **low resource usage**
+ - **Multi-platform**, runs on macOS, Linux and Windows. **Docker** images are also provided
+ - Ready to use binaries for all major platforms, including **Raspberry Pi**
+ - Automatically **monitors your library** for changes, importing new files and reloading new metadata 
+ - **Themeable**, modern and responsive **Web interface** based on [Material UI](https://material-ui.com)
+ - **Compatible** with all Subsonic/Madsonic/Airsonic [clients](https://www.navidrome.org/docs/overview/#apps)
+ - **Transcoding** on the fly. Can be set per user/player. **Opus encoding is supported**
+ - Translated to **various languages**
 
-Just head to the [releases page](https://github.com/deluan/navidrome/releases) and download the latest version for you 
-platform. There are builds available for Linux, macOS and Windows (32 and 64 bits). 
+## Documentation
+All documentation can be found in the project's website: https://www.navidrome.org/docs. 
+Here are some useful direct links:
 
-Remember to install [ffmpeg](https://ffmpeg.org/download.html) in your system, a requirement for Navidrome to work properly.
-
-If you have any issues with these binaries, or need a binary for a different platform, please 
-[open an issue](https://github.com/deluan/navidrome/issues) 
-
-### Docker
-
-[Docker images](https://hub.docker.com/r/deluan/navidrome) are available. They include everything needed to run Navidrome. Example of usage:
-
-```yaml
-# This is just an example. Customize it to your needs.
-
-version: "3"
-services:
-  navidrome:
-    image: deluan/navidrome:latest
-    ports:
-      - "4533:4533"
-    environment:
-      # All options with their default values:
-      ND_MUSICFOLDER: /music
-      ND_DATAFOLDER: /data
-      ND_SCANINTERVAL: 1m
-      ND_LOGLEVEL: info  
-      ND_PORT: 4533
-    volumes:
-      - "./data:/data"
-      - "/Users/deluan/Music/iTunes/iTunes Media/Music:/music"
-```
-
-### Build from source
-
-You will need to install [Go 1.13](https://golang.org/dl/) and [Node 13.7.0](http://nodejs.org).
-You'll also need [ffmpeg](https://ffmpeg.org) installed in your system. The setup is very strict, and 
-the steps bellow only work with these specific versions (enforced in the Makefile) 
-
-After the prerequisites above are installed, clone this repository and build the application with:
-
-```shell script
-$ git clone https://github.com/deluan/navidrome
-$ cd navidrome
-$ make setup        # Install tools required for Navidrome's development 
-$ make buildall     # Build UI and server, generates a single executable
-```
-
-This will generate the `navidrome` binary executable in the project's root folder. 
-
-### Running for the first time
-
-Start the server with:
-```shell script
-./navidrome
-```
-The server should start listening for requests on the default port __4533__
-
-After starting Navidrome for the first time, go to http://localhost:4533. It will ask you to create your first admin 
-user.
-
-For more options, run `navidrome --help` 
+- [Overview](https://www.navidrome.org/docs/overview/)
+- [Installation](https://www.navidrome.org/docs/installation/)
+  - [Docker](https://www.navidrome.org/docs/installation/docker/)
+  - [Binaries](https://www.navidrome.org/docs/installation/pre-built-binaries/)
+  - [Build from source](https://www.navidrome.org/docs/installation/build-from-source/)
+- [Development](https://www.navidrome.org/docs/developers/)
+- [Subsonic API Compatibility](https://www.navidrome.org/docs/developers/subsonic-api/)
 
 ## Screenshots
 
-<p align="center">
-<p float="left">
-    <img width="270" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/screenshot-login-mobile.png">
-    <img width="270" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/screenshot-mobile.png">
-    <img width="270" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/screenshot-users-mobile.png">
-    <img width="900"src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/screenshot-desktop.png">
+<p align="left">
+    <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>
-</p>
-
-
-## Subsonic API Version Compatibility
-
-Check the up to date [compatibility table](https://github.com/deluan/navidrome/blob/master/API_COMPATIBILITY.md) 
-for the latest Subsonic features available.

assets/external.go

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

banner.go

@@ -1,20 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/deluan/navidrome/consts"
-	"github.com/deluan/navidrome/static"
-)
-
-func getBanner() string {
-	data, _ := static.Asset("banner.txt")
-	return strings.TrimSuffix(string(data), "\n")
-}
-
-func ShowBanner() {
-	version := "Version: " + consts.Version()
-	padding := strings.Repeat(" ", 52-len(version))
-	fmt.Printf("%s%s%s\n\n", getBanner(), padding, version)
-}

bin/extract_itunes_artwork.sh

@@ -1,98 +0,0 @@
-#!/bin/bash
-# Script to transfort .itc files into images (JPG or PNG)
-#
-# .itc files are located in ~/Music/iTunes/Album Artwork
-#
-# This script uses (/!\ needs ) ImageMagick's convert, hexdump, printf and dd.
-#
-# This script might be a little slow, You might want to look at Simon Kennedy's work at http://www.sffjunkie.co.uk/python-itc.html
-#
-# ~/{Library Path}/Album Artwork/Cache/D989408F65D05F99/04/13/04/D989408F65D05F99-EB5B7A9086F4B4D4.itc
-#
-# The filenames are an amalgam of the library ID (D989408F65D05F99) and the track's ID (EB5B7A9086F4B4D4).
-# The directory structure comes from the library ID and the last three digits of the track's ID converted to decimal,
-# ie 4D4 becomes 04, 13, 04.
-#
-
-AlbumArtwork="${HOME}/Music/iTunes 1/Album Artwork"
-DestinationDir="Artwork"
-IFS=$'\n'
-
-
-if [ ! -d "$DestinationDir" ]; then
-	mkdir "$DestinationDir"
-	echo "new Images dir"
-fi
-
-for file in `find "$AlbumArtwork" -name '*.itc'`; do
-	start=0x11C
-	exit=0;
-	i=1;
-	echo $file
-	while [ 1 ]; do
-
-		typeOffset=$(($start+0x30))
-		imageType=$(hexdump -n 4 -s $typeOffset -e '"0x"4/1 "%02x" "\n"' $file)
-
-		#If there is no next byte, jump to the next itc file.
-		if [[ -z $imageType ]]; then
-			break
-		fi
-
-		imageOffsetOffset=$(($start+8))
-
-		itemSize=$(hexdump -n 4 -s $start -e '"0x"4/1 "%02x" "\n"' $file)
-		imageOffset=$(hexdump -n 4 -s $imageOffsetOffset -e '"0x"4/1 "%02x" "\n"' $file)
-
-		imageStart=$(($start+$imageOffset))
-		imageSize=$(($itemSize-imageOffset))
-
-		imageWidth=$(hexdump -n 4 -s $(($start+56)) -e '"0x"4/1 "%02x" "\n"' $file)
-		imageWidth=$(printf "%d" $imageWidth)
-		imageHeight=$(hexdump -n 4 -s $(($start+60)) -e '"0x"4/1 "%02x" "\n"' $file)
-		imageHeight=$(printf "%d" $imageHeight)
-
-		dir=$(dirname "$file")
-		xbase=${file##*/} #file.etc
-		xpref=${xbase%.*} #file prefix
-
-		#echo $file
-		#echo itemsize $itemSize
-		#echo start $start
-		#echo imageOffset $imageOffset
-		#echo imageStart $imageStart
-		#echo imageSize $imageSize
-		#echo imageWidth $imageWidth
-		#echo imageHeight $imageHeight
-
-		if [[ $imageType -eq 0x504E4766 ]] || [[ $imageType -eq 0x0000000E ]] ; then
-			targetFile="$DestinationDir/$xpref-$i.png"
-			if [ ! -f "$targetFile" ]; then
-				echo PNG
-				dd skip=$imageStart count=$imageSize if="$file" of="$targetFile" bs=1 &> /dev/null
-			fi
-		elif [[ $imageType -eq 0x41524762 ]] ; then
-			targetFile="$DestinationDir/$xpref-$i.png"
-			if [ ! -f "$targetFile" ]; then
-				echo ARGB
-				dd skip=$imageStart count=$imageSize if="$file" of="$TMPDIR/test$i" bs=1 &> /dev/null
-
-				#Using a matrix to convert ARGB to RGBA since imagemagick does only support rgba input
-				convert -size $imageWidth"x"$imageHeight -depth 8 -color-matrix '0 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0' rgba:"$TMPDIR/test$i" "$targetFile"
-			fi
-		elif [[ $imageType -eq 0x0000000D ]] ; then
-			targetFile="$DestinationDir/$xpref-$i.jpg"
-			if [ ! -f "$targetFile" ]; then
-				echo JPG
-				dd skip=$imageStart count=$imageSize if="$file" of="$targetFile" bs=1 &> /dev/null
-			fi
-		else
-			echo $imageType
-			exit=1
-			break;
-		fi
-
-		start=$(($start+$itemSize))
-		i=$(($i+1))
-	done
-done

bin/fmt.sh

@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-
-gofmtcmd=`which goimports || echo "gofmt"`
-
-gofiles=$(git diff --name-only --diff-filter=ACM | grep '.go$')
-[ -z "$gofiles" ] && exit 0
-
-unformatted=`$gofmtcmd -l $gofiles`
-[ -z "$unformatted" ] && exit 0
-
-for f in $unformatted; do
-    $gofmtcmd -w -l "$f"
-    gofmt -s -w -l "$f"
-done

cmd/root.go

@@ -0,0 +1,198 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"time"
+
+	"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"
+)
+
+var (
+	cfgFile  string
+	noBanner bool
+
+	rootCmd = &cobra.Command{
+		Use:   "navidrome",
+		Short: "Navidrome is a self-hosted music server and streamer",
+		Long: `Navidrome is a self-hosted music server and streamer.
+Complete documentation is available at https://www.navidrome.org/docs`,
+		PersistentPreRun: func(cmd *cobra.Command, args []string) {
+			preRun()
+		},
+		Run: func(cmd *cobra.Command, args []string) {
+			runNavidrome()
+		},
+		Version: consts.Version(),
+	}
+)
+
+func Execute() {
+	rootCmd.SetVersionTemplate(`{{println .Version}}`)
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func preRun() {
+	if !noBanner {
+		println(consts.Banner())
+	}
+	conf.Load()
+}
+
+func runNavidrome() {
+	db.EnsureLatestVersion()
+
+	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", "schedule", schedule)
+	}
+
+	if err := g.Run(); err != nil {
+		log.Error("Fatal error in Navidrome. Aborting", err)
+	}
+}
+
+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)
+	})
+
+	rootCmd.PersistentFlags().StringVarP(&cfgFile, "configfile", "c", "", `config file (default "./navidrome.toml")`)
+	rootCmd.PersistentFlags().BoolVarP(&noBanner, "nobanner", "n", false, `don't show banner`)
+	rootCmd.PersistentFlags().String("musicfolder", viper.GetString("musicfolder"), "folder where your music is stored")
+	rootCmd.PersistentFlags().String("datafolder", viper.GetString("datafolder"), "folder to store application data (DB, cache...), needs write access")
+	rootCmd.PersistentFlags().StringP("loglevel", "l", viper.GetString("loglevel"), "log level, possible values: error, info, debug, trace")
+
+	_ = viper.BindPFlag("musicfolder", rootCmd.PersistentFlags().Lookup("musicfolder"))
+	_ = viper.BindPFlag("datafolder", rootCmd.PersistentFlags().Lookup("datafolder"))
+	_ = viper.BindPFlag("loglevel", rootCmd.PersistentFlags().Lookup("loglevel"))
+
+	rootCmd.Flags().StringP("address", "a", viper.GetString("address"), "IP address to bind")
+	rootCmd.Flags().IntP("port", "p", viper.GetInt("port"), "HTTP port Navidrome will use")
+	rootCmd.Flags().Duration("sessiontimeout", viper.GetDuration("sessiontimeout"), "how long Navidrome will wait before closing web ui idle sessions")
+	rootCmd.Flags().Duration("scaninterval", viper.GetDuration("scaninterval"), "how frequently to scan for changes in your music library")
+	rootCmd.Flags().String("baseurl", viper.GetString("baseurl"), "base URL (only the path part) to configure Navidrome behind a proxy (ex: /music)")
+	rootCmd.Flags().String("uiloginbackgroundurl", viper.GetString("uiloginbackgroundurl"), "URL to a backaground image used in the Login page")
+	rootCmd.Flags().Bool("enabletranscodingconfig", viper.GetBool("enabletranscodingconfig"), "enables transcoding configuration in the UI")
+	rootCmd.Flags().String("transcodingcachesize", viper.GetString("transcodingcachesize"), "size of transcoding cache")
+	rootCmd.Flags().String("imagecachesize", viper.GetString("imagecachesize"), "size of image (art work) cache. set to 0 to disable cache")
+	rootCmd.Flags().Bool("autoimportplaylists", viper.GetBool("autoimportplaylists"), "enable/disable .m3u playlist auto-import`")
+
+	_ = viper.BindPFlag("address", rootCmd.Flags().Lookup("address"))
+	_ = viper.BindPFlag("port", rootCmd.Flags().Lookup("port"))
+	_ = viper.BindPFlag("sessiontimeout", rootCmd.Flags().Lookup("sessiontimeout"))
+	_ = viper.BindPFlag("scaninterval", rootCmd.Flags().Lookup("scaninterval"))
+	_ = viper.BindPFlag("baseurl", rootCmd.Flags().Lookup("baseurl"))
+	_ = viper.BindPFlag("uiloginbackgroundurl", rootCmd.Flags().Lookup("uiloginbackgroundurl"))
+	_ = viper.BindPFlag("enabletranscodingconfig", rootCmd.Flags().Lookup("enabletranscodingconfig"))
+	_ = viper.BindPFlag("transcodingcachesize", rootCmd.Flags().Lookup("transcodingcachesize"))
+	_ = viper.BindPFlag("imagecachesize", rootCmd.Flags().Lookup("imagecachesize"))
+}

cmd/scan.go

@@ -0,0 +1,36 @@
+package cmd
+
+import (
+	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/log"
+	"github.com/spf13/cobra"
+	"golang.org/x/net/context"
+)
+
+var fullRescan bool
+
+func init() {
+	scanCmd.Flags().BoolVarP(&fullRescan, "full", "f", false, "check all subfolders, ignoring timestamps")
+	rootCmd.AddCommand(scanCmd)
+}
+
+var scanCmd = &cobra.Command{
+	Use:   "scan",
+	Short: "Scan music folder",
+	Long:  "Scan music folder for updates",
+	Run: func(cmd *cobra.Command, args []string) {
+		runScanner()
+	},
+}
+
+func runScanner() {
+	conf.Server.DevPreCacheAlbumArtwork = false
+
+	scanner := GetScanner()
+	_ = scanner.RescanAll(context.Background(), fullRescan)
+	if fullRescan {
+		log.Info("Finished full rescan")
+	} else {
+		log.Info("Finished rescan")
+	}
+}

cmd/signaler_unix.go

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

cmd/wire_gen.go

@@ -0,0 +1,95 @@
+// Code generated by Wire. DO NOT EDIT.
+
+//go:generate go run github.com/google/wire/cmd/wire
+//+build !wireinject
+
+package cmd
+
+import (
+	"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 {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	serverServer := server.New(dataStore)
+	return serverServer
+}
+
+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 {
+	sqlDB := db.Db()
+	dataStore := persistence.New(sqlDB)
+	artworkCache := core.GetImageCache()
+	artwork := core.NewArtwork(dataStore, artworkCache)
+	transcoderTranscoder := transcoder.New()
+	transcodingCache := core.GetTranscodingCache()
+	mediaStreamer := core.NewMediaStreamer(dataStore, transcoderTranscoder, transcodingCache)
+	archiver := core.NewArchiver(dataStore)
+	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(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

@@ -0,0 +1,74 @@
+//+build wireinject
+
+package cmd
+
+import (
+	"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(
+	core.Set,
+	subsonic.New,
+	nativeapi.New,
+	persistence.New,
+	lastfm.NewRouter,
+	events.GetBroker,
+	db.Db,
+)
+
+func CreateServer(musicFolder string) *server.Server {
+	panic(wire.Build(
+		server.New,
+		allProviders,
+	))
+}
+
+func CreateNativeAPIRouter() *nativeapi.Router {
+	panic(wire.Build(
+		allProviders,
+	))
+}
+
+func CreateSubsonicAPIRouter() *subsonic.Router {
+	panic(wire.Build(
+		allProviders,
+		GetScanner,
+	))
+}
+
+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

@@ -1,94 +1,268 @@
 package conf
 
 import (
-	"flag"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 
-	"github.com/deluan/navidrome/consts"
-	"github.com/deluan/navidrome/log"
-	"github.com/koding/multiconfig"
+	"github.com/kr/pretty"
+	"github.com/navidrome/navidrome/consts"
+	"github.com/navidrome/navidrome/log"
+	"github.com/robfig/cron/v3"
+	"github.com/spf13/viper"
 )
 
-type nd struct {
-	Port        string `default:"4533"`
-	MusicFolder string `default:"./music"`
-	DataFolder  string `default:"./"`
-	DbPath      string
-	LogLevel    string `default:"info"`
+type configOptions struct {
+	ConfigFile              string
+	Address                 string
+	Port                    int
+	MusicFolder             string
+	DataFolder              string
+	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
 
-	IgnoredArticles string `default:"The El La Los Las Le Les Os As O A"`
-	IndexGroups     string `default:"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]([)"`
+	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
 
-	DisableDownsampling bool   `default:"false"`
-	DownsampleCommand   string `default:"ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -f mp3 -"`
-	ProbeCommand        string `default:"ffmpeg %s -f ffmetadata"`
-	ScanInterval        string `default:"1m"`
+	Scanner scannerOptions
+
+	Agents  string
+	LastFM  lastfmOptions
+	Spotify spotifyOptions
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
-	DevDisableAuthentication bool `default:"false"`
-	DevDisableBanner         bool `default:"false"`
+	DevLogSourceLine           bool
+	DevLogLevels               map[string]string
+	DevAutoCreateAdminPassword string
+	DevAutoLoginUsername       string
+	DevPreCacheAlbumArtwork    bool
+	DevFastAccessCoverArt      bool
+	DevActivityPanel           bool
+	DevEnableShare             bool
+	DevEnableBufferedScrobble  bool
 }
 
-var Server = &nd{}
-
-func newWithPath(path string, skipFlags ...bool) *multiconfig.DefaultLoader {
-	var loaders []multiconfig.Loader
-
-	// Read default values defined via tag fields "default"
-	loaders = append(loaders, &multiconfig.TagLoader{})
-
-	if _, err := os.Stat(path); err == nil {
-		if strings.HasSuffix(path, "toml") {
-			loaders = append(loaders, &multiconfig.TOMLLoader{Path: path})
-		}
-
-		if strings.HasSuffix(path, "json") {
-			loaders = append(loaders, &multiconfig.JSONLoader{Path: path})
-		}
-
-		if strings.HasSuffix(path, "yml") || strings.HasSuffix(path, "yaml") {
-			loaders = append(loaders, &multiconfig.YAMLLoader{Path: path})
-		}
-	}
-
-	e := &multiconfig.EnvironmentLoader{}
-	loaders = append(loaders, e)
-	if len(skipFlags) == 0 || !skipFlags[0] {
-		f := &multiconfig.FlagLoader{}
-		loaders = append(loaders, f)
-	}
-
-	loader := multiconfig.MultiLoader(loaders...)
-
-	d := &multiconfig.DefaultLoader{}
-	d.Loader = loader
-	d.Validator = multiconfig.MultiValidator(&multiconfig.RequiredValidator{})
-	return d
+type scannerOptions struct {
+	Extractor       string
+	GenreSeparators string
 }
 
-func LoadFromFile(confFile string, skipFlags ...bool) {
-	m := newWithPath(confFile, skipFlags...)
-	err := m.Load(Server)
-	if err == flag.ErrHelp {
-		os.Exit(1)
-	}
-	if err != nil {
-		fmt.Printf("Error trying to load config '%s'. Error: %v", confFile, err)
-		os.Exit(2)
-	}
-	if Server.DbPath == "" {
-		Server.DbPath = filepath.Join(Server.DataFolder, "navidrome.db")
-	}
-	if os.Getenv("PORT") != "" {
-		Server.Port = os.Getenv("PORT")
-	}
-	log.SerLevelString(Server.LogLevel)
-	log.Trace("Loaded configuration", "file", confFile, "config", fmt.Sprintf("%#v", Server))
+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)
+	Load()
 }
 
 func Load() {
-	LoadFromFile(consts.LocalConfigFile)
+	err := viper.Unmarshal(&Server)
+	if err != nil {
+		fmt.Println("FATAL: Error parsing config:", err)
+		os.Exit(1)
+	}
+	err = os.MkdirAll(Server.DataFolder, os.ModePerm)
+	if err != nil {
+		fmt.Println("FATAL: Error creating data path:", "path", Server.DataFolder, err)
+		os.Exit(1)
+	}
+	Server.ConfigFile = viper.GetViper().ConfigFileUsed()
+	if Server.DbPath == "" {
+		Server.DbPath = filepath.Join(Server.DataFolder, consts.DefaultDbPath)
+	}
+
+	log.SetLevelString(Server.LogLevel)
+	log.SetLogLevels(Server.DevLogLevels)
+	log.SetLogSourceLine(Server.DevLogSourceLine)
+	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 == "" {
+		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() {
+	viper.SetDefault("musicfolder", filepath.Join(".", "music"))
+	viper.SetDefault("datafolder", ".")
+	viper.SetDefault("loglevel", "info")
+	viper.SetDefault("address", "0.0.0.0")
+	viper.SetDefault("port", 4533)
+	viper.SetDefault("sessiontimeout", consts.DefaultSessionTimeout)
+	viper.SetDefault("scaninterval", -1)
+	viper.SetDefault("scanschedule", "@every 1m")
+	viper.SetDefault("baseurl", "")
+	viper.SetDefault("uiloginbackgroundurl", consts.DefaultUILoginBackgroundURL)
+	viper.SetDefault("enabletranscodingconfig", false)
+	viper.SetDefault("transcodingcachesize", "100MB")
+	viper.SetDefault("imagecachesize", "100MB")
+	viper.SetDefault("autoimportplaylists", true)
+	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("reverseproxyuserheader", "Remote-User")
+	viper.SetDefault("reverseproxywhitelist", "")
+
+	viper.SetDefault("scanner.extractor", 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("devautologinusername", "")
+	viper.SetDefault("devprecachealbumartwork", false)
+	viper.SetDefault("devfastaccesscoverart", false)
+	viper.SetDefault("devactivitypanel", true)
+	viper.SetDefault("devenableshare", false)
+	viper.SetDefault("devenablebufferedscrobble", true)
+}
+
+func InitConfig(cfgFile string) {
+	cfgFile = getConfigFile(cfgFile)
+	if cfgFile != "" {
+		// Use config file from the flag.
+		viper.SetConfigFile(cfgFile)
+	} else {
+		// Search config in local directory with name "navidrome" (without extension).
+		viper.AddConfigPath(".")
+		viper.SetConfigName("navidrome")
+	}
+
+	_ = viper.BindEnv("port")
+	viper.SetEnvPrefix("ND")
+	replacer := strings.NewReplacer(".", "_")
+	viper.SetEnvKeyReplacer(replacer)
+	viper.AutomaticEnv()
+
+	err := viper.ReadInConfig()
+	if viper.ConfigFileUsed() != "" && err != nil {
+		fmt.Println("FATAL: Navidrome could not open config file: ", err)
+		os.Exit(1)
+	}
+}
+
+func getConfigFile(cfgFile string) string {
+	if cfgFile != "" {
+		return cfgFile
+	}
+	return os.Getenv("ND_CONFIGFILE")
 }

conf/defaults.go

@@ -0,0 +1,5 @@
+// +build !windows
+
+package conf
+
+const DefaultScannerExtractor = "taglib"

conf/defaults_win.go

@@ -0,0 +1,5 @@
+// +build windows
+
+package conf
+
+const DefaultScannerExtractor = "ffmpeg"

consts/banner.go

@@ -0,0 +1,19 @@
+package consts
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+
+	"github.com/navidrome/navidrome/resources"
+)
+
+func loadBanner() string {
+	data, _ := resources.Asset("banner.txt")
+	return strings.TrimRightFunc(string(data), unicode.IsSpace)
+}
+
+func Banner() string {
+	version := "Version: " + Version()
+	return fmt.Sprintf("%s\n%52s\n", loadBanner(), version)
+}

consts/consts.go

@@ -1,16 +1,94 @@
 package consts
 
-import "time"
+import (
+	"crypto/md5"
+	"fmt"
+	"strings"
+	"time"
+)
 
 const (
 	AppName = "navidrome"
 
-	LocalConfigFile     = "./navidrome.toml"
+	DefaultDbPath       = "navidrome.db?cache=shared&_busy_timeout=15000&_journal_mode=WAL&_foreign_keys=on"
 	InitialSetupFlagKey = "InitialSetup"
 
-	JWTSecretKey       = "JWTSecret"
-	JWTIssuer          = "ND"
-	JWTTokenExpiration = 30 * time.Minute
+	UIAuthorizationHeader  = "X-ND-Authorization"
+	UIClientUniqueIDHeader = "X-ND-Client-Unique-Id"
+	JWTSecretKey           = "JWTSecret"
+	JWTIssuer              = "ND"
+	DefaultSessionTimeout  = 24 * time.Hour
+	CookieExpiry           = 365 * 24 * 3600 // One year
 
-	UIAssetsLocalPath = "ui/build"
+	// 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
+)
+
+// Cache options
+const (
+	TranscodingCacheDir             = "cache/transcoding"
+	DefaultTranscodingCacheMaxItems = 0 // Unlimited
+
+	ImageCacheDir             = "cache/images"
+	DefaultImageCacheMaxItems = 0 // Unlimited
+
+	DefaultCacheSize            = 100 * 1024 * 1024 // 100MB
+	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{}{
+		{
+			"name":           "mp3 audio",
+			"targetFormat":   "mp3",
+			"defaultBitRate": 192,
+			"command":        "ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -f mp3 -",
+		},
+		{
+			"name":           "opus audio",
+			"targetFormat":   "opus",
+			"defaultBitRate": 128,
+			"command":        "ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -c:a libopus -f opus -",
+		},
+	}
+)
+
+var (
+	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

@@ -0,0 +1,59 @@
+package consts
+
+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() {
+	for ext, fmt := range audioFormats {
+		_ = mime.AddExtensionType(ext, fmt.typ)
+		if fmt.lossless {
+			LosslessFormats = append(LosslessFormats, strings.TrimPrefix(ext, "."))
+		}
+	}
+	sort.Strings(LosslessFormats)
+	for ext, typ := range imageFormats {
+		_ = mime.AddExtensionType(ext, typ)
+	}
+}

consts/version.go

@@ -1,6 +1,9 @@
 package consts
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
 
 var (
 	// This will be set in build time. If not, version will be set to "dev"
@@ -11,10 +14,12 @@ var (
 // Formats:
 // dev
 // v0.2.0 (5b84188)
+// v0.3.2-SNAPSHOT (715f552)
 // master (9ed35cb)
 func Version() string {
 	if gitSha == "" {
 		return "dev"
 	}
+	gitTag = strings.TrimPrefix(gitTag, "v")
 	return fmt.Sprintf("%s (%s)", gitTag, gitSha)
 }

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

@@ -0,0 +1,15 @@
+#!/sbin/openrc-run
+  
+name=$RC_SVCNAME
+command="/opt/navidrome/${RC_SVCNAME}"
+command_args="-datafolder /opt/navidrome"
+command_user="${RC_SVCNAME}"
+pidfile="/var/run/${RC_SVCNAME}.pid"
+output_log="/opt/navidrome/${RC_SVCNAME}.log"
+error_log="/opt/navidrome/${RC_SVCNAME}.err"
+command_background="yes"
+
+depend() {
+        need net
+}
+

contrib/navidrome.service

@@ -0,0 +1,55 @@
+# This file ususaly goes in /etc/systemd/system
+
+[Unit]
+Description=Navidrome Music Server and Streamer compatible with Subsonic/Airsonic
+After=remote-fs.target network.target
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+User=navidrome
+Group=navidrome
+Type=simple
+ExecStart=/usr/bin/navidrome
+StateDirectory=navidrome
+WorkingDirectory=/var/lib/navidrome
+TimeoutStopSec=20
+KillMode=process
+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=@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
+#PrivateDevices=yes
+
+# You can change the following line to `strict` instead of `full` if you don't
+# want navidrome to be able to write anything on your filesystem outside of
+# /var/lib/navidrome.
+ProtectSystem=full
+
+# You can comment the following line if you don't have any media in /home/*.
+# This will prevent navidrome from ever reading/writing anything there.
+ProtectHome=true

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

@@ -0,0 +1,113 @@
+package core
+
+import (
+	"archive/zip"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+type Archiver interface {
+	ZipAlbum(ctx context.Context, id string, w io.Writer) error
+	ZipArtist(ctx context.Context, id string, w io.Writer) error
+	ZipPlaylist(ctx context.Context, id string, w io.Writer) error
+}
+
+func NewArchiver(ds model.DataStore) Archiver {
+	return &archiver{ds: ds}
+}
+
+type archiver struct {
+	ds model.DataStore
+}
+
+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).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
+	}
+	return a.zipTracks(ctx, id, out, mfs, a.createHeader)
+}
+
+func (a *archiver) ZipArtist(ctx context.Context, id string, out io.Writer) error {
+	mfs, err := a.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+		Sort:    "album",
+		Filters: squirrel.Eq{"album_artist_id": id},
+	})
+	if err != nil {
+		log.Error(ctx, "Error loading mediafiles from artist", "id", id, err)
+		return err
+	}
+	return a.zipTracks(ctx, id, out, mfs, a.createHeader)
+}
+
+func (a *archiver) ZipPlaylist(ctx context.Context, id string, out io.Writer) error {
+	pls, err := a.ds.Playlist(ctx).Get(id)
+	if err != nil {
+		log.Error(ctx, "Error loading mediafiles from playlist", "id", id, err)
+		return err
+	}
+	return a.zipTracks(ctx, id, out, pls.Tracks, a.createPlaylistHeader)
+}
+
+func (a *archiver) zipTracks(ctx context.Context, id string, out io.Writer, mfs model.MediaFiles, ch createHeader) error {
+	z := zip.NewWriter(out)
+	for idx, mf := range mfs {
+		_ = a.addFileToZip(ctx, z, mf, ch(idx, mf))
+	}
+	err := z.Close()
+	if err != nil {
+		log.Error(ctx, "Error closing zip file", "id", id, err)
+	}
+	return err
+}
+
+func (a *archiver) createHeader(idx int, mf model.MediaFile) *zip.FileHeader {
+	_, file := filepath.Split(mf.Path)
+	return &zip.FileHeader{
+		Name:     fmt.Sprintf("%s/%s", mf.Album, file),
+		Modified: mf.UpdatedAt,
+		Method:   zip.Store,
+	}
+}
+
+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+1, mf.AlbumArtist, file),
+		Modified: mf.UpdatedAt,
+		Method:   zip.Store,
+	}
+}
+
+func (a *archiver) addFileToZip(ctx context.Context, z *zip.Writer, mf model.MediaFile, zh *zip.FileHeader) error {
+	w, err := z.CreateHeader(zh)
+	if err != nil {
+		log.Error(ctx, "Error creating zip entry", "file", mf.Path, err)
+		return err
+	}
+	f, err := os.Open(mf.Path)
+	defer func() { _ = f.Close() }()
+	if err != nil {
+		log.Error(ctx, "Error opening file for zipping", "file", mf.Path, err)
+		return err
+	}
+	_, err = io.Copy(w, f)
+	if err != nil {
+		log.Error(ctx, "Error zipping file", "file", mf.Path, err)
+		return err
+	}
+	return nil
+}

core/artwork.go

@@ -0,0 +1,220 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"image"
+	_ "image/gif"
+	"image/jpeg"
+	_ "image/png"
+	"io"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"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) (io.ReadCloser, error)
+}
+
+type ArtworkCache cache.FileCache
+
+func NewArtwork(ds model.DataStore, cache ArtworkCache) Artwork {
+	return &artwork{ds: ds, cache: cache}
+}
+
+type artwork struct {
+	ds    model.DataStore
+	cache cache.FileCache
+}
+
+type imageInfo struct {
+	a          *artwork
+	id         string
+	path       string
+	size       int
+	lastUpdate time.Time
+}
+
+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 (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 nil, err
+	}
+
+	if !conf.Server.DevFastAccessCoverArt {
+		if stat, err := os.Stat(path); err == nil {
+			lastUpdate = stat.ModTime()
+		}
+	}
+
+	info := &imageInfo{
+		a:          a,
+		id:         id,
+		path:       path,
+		size:       size,
+		lastUpdate: lastUpdate,
+	}
+
+	r, err := a.cache.Get(ctx, info)
+	if err != nil {
+		log.Error(ctx, "Error accessing image cache", "path", path, "size", size, err)
+		return nil, err
+	}
+	return r, err
+}
+
+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 = a.ds.Album(ctx).Get(id)
+		if err != nil {
+			return
+		}
+		if al.CoverArtId == "" {
+			err = model.ErrNotFound
+		}
+		return al.CoverArtPath, al.UpdatedAt, err
+	}
+
+	log.Trace(ctx, "Looking for media file art", "id", id)
+
+	// Check if id is a mediaFile id
+	var mf *model.MediaFile
+	mf, err = a.ds.MediaFile(ctx).Get(id)
+
+	// If it is not, may be an albumId
+	if err == model.ErrNotFound {
+		return a.getImagePath(ctx, "al-"+id)
+	}
+	if err != nil {
+		return
+	}
+
+	// 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 a.getImagePath(ctx, "al-"+mf.AlbumID)
+}
+
+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.FS.Open(consts.PlaceholderAlbumArt)
+		}
+	}()
+
+	if path == "" {
+		return nil, errors.New("empty path given for artwork")
+	}
+
+	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 {
+		// 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)
+	}
+
+	return
+}
+
+func resizeImage(reader io.Reader, size int) (io.ReadCloser, error) {
+	img, _, err := image.Decode(reader)
+	if err != nil {
+		return nil, err
+	}
+
+	// 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 io.NopCloser(buf), err
+}
+
+func readFromTag(path string) (io.ReadCloser, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	m, err := tag.ReadFrom(f)
+	if err != nil {
+		return nil, err
+	}
+
+	picture := m.Picture()
+	if picture == nil {
+		return nil, errors.New("file does not contain embedded art")
+	}
+	return io.NopCloser(bytes.NewReader(picture.Data)), nil
+}
+
+func readFromFile(path string) (io.ReadCloser, error) {
+	return os.Open(path)
+}
+
+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

@@ -0,0 +1,141 @@
+package core
+
+import (
+	"context"
+	"image"
+	"os"
+
+	"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"
+)
+
+var _ = Describe("Artwork", func() {
+	var artwork Artwork
+	var ds model.DataStore
+	ctx := log.NewContext(context.TODO())
+
+	BeforeEach(func() {
+		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, _ = os.MkdirTemp("", "file_caches")
+			conf.Server.ImageCacheSize = "100MB"
+			cache := GetImageCache()
+			Eventually(func() bool { return cache.Ready(context.TODO()) }).Should(BeTrue())
+			artwork = NewArtwork(ds, cache)
+		})
+
+		It("retrieves the external artwork art for an album", func() {
+			r, err := artwork.Get(ctx, "al-444", 0)
+			Expect(err).To(BeNil())
+
+			_, 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() {
+			r, err := artwork.Get(ctx, "al-222", 0)
+			Expect(err).To(BeNil())
+
+			_, 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() {
+			r, err := artwork.Get(ctx, "al-333", 0)
+			Expect(err).To(BeNil())
+
+			_, 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() {
+			r, err := artwork.Get(ctx, "al-0101", 0)
+			Expect(err).To(BeNil())
+
+			_, 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() {
+			r, err := artwork.Get(ctx, "123", 0)
+			Expect(err).To(BeNil())
+
+			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() {
+			r, err := artwork.Get(ctx, "456", 0)
+			Expect(err).To(BeNil())
+
+			_, 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() {
+			r, err := artwork.Get(ctx, "222", 0)
+			Expect(err).To(BeNil())
+
+			_, 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() {
+			r, err := artwork.Get(ctx, "123", 200)
+			Expect(err).To(BeNil())
+
+			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).(*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).(*tests.MockMediaFileRepo).SetError(true)
+				_, err := artwork.Get(ctx, "123", 0)
+				Expect(err).To(MatchError("Error!"))
+			})
+		})
+	})
+})

core/auth/auth.go

@@ -0,0 +1,67 @@
+package auth
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"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
+	Secret    []byte
+	TokenAuth *jwtauth.JWTAuth
+)
+
+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)
+		}
+		Secret = []byte(secret)
+		TokenAuth = jwtauth.New("HS256", Secret, nil)
+	})
+}
+
+func CreateToken(u *model.User) (string, error) {
+	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 TouchToken(token jwt.Token) (string, error) {
+	claims, err := token.AsMap(context.Background())
+	if err != nil {
+		return "", err
+	}
+
+	claims[jwt.ExpirationKey] = time.Now().UTC().Add(conf.Server.SessionTimeout).Unix()
+	_, newToken, err := TokenAuth.Encode(claims)
+
+	return newToken, err
+}
+
+func Validate(tokenStr string) (map[string]interface{}, error) {
+	token, err := jwtauth.VerifyToken(TokenAuth, tokenStr)
+	if err != nil {
+		return nil, err
+	}
+	return token.AsMap(context.Background())
+}

core/auth/auth_test.go

@@ -0,0 +1,108 @@
+package auth_test
+
+import (
+	"testing"
+	"time"
+
+	"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"
+)
+
+func TestAuth(t *testing.T) {
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Auth Test Suite")
+}
+
+const (
+	testJWTSecret = "not so secret"
+	oneDay        = 24 * time.Hour
+)
+
+var _ = Describe("Auth", func() {
+	BeforeSuite(func() {
+		conf.Server.SessionTimeout = 2 * oneDay
+	})
+
+	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(HaveOccurred())
+		})
+
+		It("returns the claims from a valid JWT token", func() {
+			claims := map[string]interface{}{}
+			claims["iss"] = "issuer"
+			claims["iat"] = time.Now().Unix()
+			claims["exp"] = time.Now().Add(1 * time.Minute).Unix()
+			_, tokenStr, err := auth.TokenAuth.Encode(claims)
+			Expect(err).NotTo(HaveOccurred())
+
+			decodedClaims, err := auth.Validate(tokenStr)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(decodedClaims["iss"]).To(Equal("issuer"))
+		})
+
+		It("returns ErrExpired if the `exp` field is in the past", func() {
+			claims := map[string]interface{}{}
+			claims["iss"] = "issuer"
+			claims["exp"] = time.Now().Add(-1 * time.Minute).Unix()
+			_, tokenStr, err := auth.TokenAuth.Encode(claims)
+			Expect(err).NotTo(HaveOccurred())
+
+			_, 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

@@ -0,0 +1,15 @@
+package core
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/model/request"
+)
+
+func userName(ctx context.Context) string {
+	if user, ok := request.UserFrom(ctx); !ok {
+		return "UNKNOWN"
+	} else {
+		return user.UserName
+	}
+}

core/core_suite_test.go

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

core/external_metadata.go

@@ -0,0 +1,394 @@
+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{"id": ids},
+	})
+	if err != nil {
+		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

@@ -0,0 +1,194 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"mime"
+	"os"
+	"sync"
+	"time"
+
+	"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 cache.FileCache
+
+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
+	transcoder transcoder.Transcoder
+	cache      cache.FileCache
+}
+
+type streamJob struct {
+	ms      *mediaStreamer
+	mf      *model.MediaFile
+	format  string
+	bitRate int
+}
+
+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)
+}
+
+func (ms *mediaStreamer) NewStream(ctx context.Context, id string, reqFormat string, reqBitRate int) (*Stream, error) {
+	mf, err := ms.ds.MediaFile(ctx).Get(id)
+	if err != nil {
+		return nil, err
+	}
+
+	var format string
+	var bitRate int
+	var cached bool
+	defer func() {
+		log.Info("Streaming file", "title", mf.Title, "artist", mf.Artist, "format", format, "cached", cached,
+			"bitRate", bitRate, "user", userName(ctx), "transcoding", format != "raw",
+			"originalFormat", mf.Suffix, "originalBitRate", mf.BitRate)
+	}()
+
+	format, bitRate = selectTranscodingOptions(ctx, ms.ds, mf, reqFormat, reqBitRate)
+	s := &Stream{ctx: ctx, mf: mf, format: format, bitRate: bitRate}
+
+	if format == "raw" {
+		log.Debug(ctx, "Streaming RAW file", "id", mf.ID, "path", mf.Path,
+			"requestBitrate", reqBitRate, "requestFormat", reqFormat,
+			"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix,
+			"selectedBitrate", bitRate, "selectedFormat", format)
+		f, err := os.Open(mf.Path)
+		if err != nil {
+			return nil, err
+		}
+		s.ReadCloser = f
+		s.Seeker = f
+		s.format = mf.Suffix
+		return s, nil
+	}
+
+	job := &streamJob{
+		ms:      ms,
+		mf:      mf,
+		format:  format,
+		bitRate: bitRate,
+	}
+	r, err := ms.cache.Get(ctx, job)
+	if err != nil {
+		log.Error(ctx, "Error accessing transcoding cache", "id", mf.ID, err)
+		return nil, err
+	}
+	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())
+
+	return s, nil
+}
+
+type Stream struct {
+	ctx     context.Context
+	mf      *model.MediaFile
+	bitRate int
+	format  string
+	io.ReadCloser
+	io.Seeker
+}
+
+func (s *Stream) Seekable() bool      { return s.Seeker != nil }
+func (s *Stream) Duration() float32   { return s.mf.Duration }
+func (s *Stream) ContentType() string { return mime.TypeByExtension("." + s.format) }
+func (s *Stream) Name() string        { return s.mf.Title + "." + s.format }
+func (s *Stream) ModTime() time.Time  { return s.mf.UpdatedAt }
+func (s *Stream) EstimatedContentLength() int {
+	return int(s.mf.Duration * float32(s.bitRate) / 8 * 1024)
+}
+
+// TODO This function deserves some love (refactoring)
+func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model.MediaFile, reqFormat string, reqBitRate int) (format string, bitRate int) {
+	format = "raw"
+	if reqFormat == "raw" {
+		return
+	}
+	if reqFormat == mf.Suffix && reqBitRate == 0 {
+		bitRate = mf.BitRate
+		return
+	}
+	trc, hasDefault := request.TranscodingFrom(ctx)
+	var cFormat string
+	var cBitRate int
+	if reqFormat != "" {
+		cFormat = reqFormat
+	} else {
+		if hasDefault {
+			cFormat = trc.TargetFormat
+			cBitRate = trc.DefaultBitRate
+			if p, ok := request.PlayerFrom(ctx); ok {
+				cBitRate = p.MaxBitRate
+			}
+		}
+	}
+	if reqBitRate > 0 {
+		cBitRate = reqBitRate
+	}
+	if cBitRate == 0 && cFormat == "" {
+		return
+	}
+	t, err := ds.Transcoding(ctx).FindByFormat(cFormat)
+	if err == nil {
+		format = t.TargetFormat
+		if cBitRate != 0 {
+			bitRate = cBitRate
+		} else {
+			bitRate = t.DefaultBitRate
+		}
+	}
+	if format == mf.Suffix && bitRate >= mf.BitRate {
+		format = "raw"
+		bitRate = 0
+	}
+	return
+}
+
+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

@@ -0,0 +1,211 @@
+package core
+
+import (
+	"context"
+	"io"
+	"os"
+	"strings"
+
+	"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"
+)
+
+var _ = Describe("MediaStreamer", func() {
+	var streamer MediaStreamer
+	var ds model.DataStore
+	ffmpeg := &fakeFFmpeg{Data: "fake data"}
+	ctx := log.NewContext(context.TODO())
+
+	BeforeEach(func() {
+		conf.Server.DataFolder, _ = os.MkdirTemp("", "file_caches")
+		conf.Server.TranscodingCacheSize = "100MB"
+		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)
+	})
+
+	Context("NewStream", func() {
+		It("returns a seekable stream if format is 'raw'", func() {
+			s, err := streamer.NewStream(ctx, "123", "raw", 0)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
+		})
+		It("returns a seekable stream if maxBitRate is 0", func() {
+			s, err := streamer.NewStream(ctx, "123", "mp3", 0)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
+		})
+		It("returns a seekable stream if maxBitRate is higher than file bitRate", func() {
+			s, err := streamer.NewStream(ctx, "123", "mp3", 320)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(s.Seekable()).To(BeTrue())
+		})
+		It("returns a NON seekable stream if transcode is required", func() {
+			s, err := streamer.NewStream(ctx, "123", "mp3", 64)
+			Expect(err).To(BeNil())
+			Expect(s.Seekable()).To(BeFalse())
+			Expect(s.Duration()).To(Equal(float32(257.0)))
+		})
+		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())
+			_, _ = io.ReadAll(s)
+			_ = s.Close()
+			Eventually(func() bool { return ffmpeg.closed }, "3s").Should(BeTrue())
+
+			s, err = streamer.NewStream(ctx, "123", "mp3", 32)
+			Expect(err).To(BeNil())
+			Expect(s.Seekable()).To(BeTrue())
+		})
+	})
+
+	Context("selectTranscodingOptions", func() {
+		mf := &model.MediaFile{}
+		Context("player is not configured", func() {
+			It("returns raw if raw is requested", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0)
+				Expect(format).To(Equal("raw"))
+			})
+			It("returns raw if a transcoder does not exists", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "m4a", 0)
+				Expect(format).To(Equal("raw"))
+			})
+			It("returns the requested format if a transcoder exists", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				Expect(format).To(Equal("mp3"))
+				Expect(bitRate).To(Equal(160)) // Default Bit Rate
+			})
+			It("returns raw if requested format is the same as the original and it is not necessary to downsample", func() {
+				mf.Suffix = "mp3"
+				mf.BitRate = 112
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "mp3", 128)
+				Expect(format).To(Equal("raw"))
+			})
+			It("returns the requested format if requested BitRate is lower than original", func() {
+				mf.Suffix = "mp3"
+				mf.BitRate = 320
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 192)
+				Expect(format).To(Equal("mp3"))
+				Expect(bitRate).To(Equal(192))
+			})
+			It("returns raw if requested format is the same as the original, but requested BitRate is 0", func() {
+				mf.Suffix = "mp3"
+				mf.BitRate = 320
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				Expect(format).To(Equal("raw"))
+				Expect(bitRate).To(Equal(320))
+			})
+		})
+
+		Context("player has format configured", func() {
+			BeforeEach(func() {
+				t := model.Transcoding{ID: "oga1", TargetFormat: "oga", DefaultBitRate: 96}
+				ctx = request.WithTranscoding(ctx, t)
+			})
+			It("returns raw if raw is requested", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0)
+				Expect(format).To(Equal("raw"))
+			})
+			It("returns configured format/bitrate as default", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 0)
+				Expect(format).To(Equal("oga"))
+				Expect(bitRate).To(Equal(96))
+			})
+			It("returns requested format", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				Expect(format).To(Equal("mp3"))
+				Expect(bitRate).To(Equal(160)) // Default Bit Rate
+			})
+			It("returns requested bitrate", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 80)
+				Expect(format).To(Equal("oga"))
+				Expect(bitRate).To(Equal(80))
+			})
+			It("returns raw if selected bitrate and format is the same as original", func() {
+				mf.Suffix = "mp3"
+				mf.BitRate = 192
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 192)
+				Expect(format).To(Equal("raw"))
+				Expect(bitRate).To(Equal(0))
+			})
+		})
+		Context("player has maxBitRate configured", func() {
+			BeforeEach(func() {
+				t := model.Transcoding{ID: "oga1", TargetFormat: "oga", DefaultBitRate: 96}
+				p := model.Player{ID: "player1", TranscodingId: t.ID, MaxBitRate: 80}
+				ctx = request.WithTranscoding(ctx, t)
+				ctx = request.WithPlayer(ctx, p)
+			})
+			It("returns raw if raw is requested", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0)
+				Expect(format).To(Equal("raw"))
+			})
+			It("returns configured format/bitrate as default", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 0)
+				Expect(format).To(Equal("oga"))
+				Expect(bitRate).To(Equal(80))
+			})
+			It("returns requested format", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				Expect(format).To(Equal("mp3"))
+				Expect(bitRate).To(Equal(160)) // Default Bit Rate
+			})
+			It("returns requested bitrate", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 80)
+				Expect(format).To(Equal("oga"))
+				Expect(bitRate).To(Equal(80))
+			})
+		})
+	})
+})
+
+type fakeFFmpeg struct {
+	Data   string
+	r      io.Reader
+	closed bool
+}
+
+func (ff *fakeFFmpeg) Start(ctx context.Context, cmd, path string, maxBitRate int) (f io.ReadCloser, err error) {
+	ff.r = strings.NewReader(ff.Data)
+	return ff, nil
+}
+
+func (ff *fakeFFmpeg) Read(p []byte) (n int, err error) {
+	return ff.r.Read(p)
+}
+
+func (ff *fakeFFmpeg) Close() error {
+	ff.closed = true
+	return nil
+}

core/players.go

@@ -0,0 +1,68 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/model/request"
+)
+
+type Players interface {
+	Get(ctx context.Context, playerId string) (*model.Player, error)
+	Register(ctx context.Context, id, client, typ, ip string) (*model.Player, *model.Transcoding, error)
+}
+
+func NewPlayers(ds model.DataStore) Players {
+	return &players{ds}
+}
+
+type players struct {
+	ds model.DataStore
+}
+
+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
+	userName, _ := request.UsernameFrom(ctx)
+	if id != "" {
+		plr, err = p.ds.Player(ctx).Get(id)
+		if err == nil && plr.Client != client {
+			id = ""
+		}
+	}
+	if err != nil || id == "" {
+		plr, err = p.ds.Player(ctx).FindMatch(userName, client, userAgent)
+		if err == nil {
+			log.Debug("Found matching player", "id", plr.ID, "client", client, "username", userName, "type", userAgent)
+		} else {
+			plr = &model.Player{
+				ID:              uuid.NewString(),
+				UserName:        userName,
+				Client:          client,
+				ScrobbleEnabled: true,
+			}
+			log.Info("Registering new player", "id", plr.ID, "client", client, "username", userName, "type", userAgent)
+		}
+	}
+	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
+	}
+	if plr.TranscodingId != "" {
+		trc, err = p.ds.Transcoding(ctx).Get(plr.TranscodingId)
+	}
+	return plr, trc, err
+}
+
+func (p *players) Get(ctx context.Context, playerId string) (*model.Player, error) {
+	return p.ds.Player(ctx).Get(playerId)
+}

core/players_test.go

@@ -0,0 +1,140 @@
+package core
+
+import (
+	"context"
+	"time"
+
+	"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"
+)
+
+var _ = Describe("Players", func() {
+	var players Players
+	var repo *mockPlayerRepository
+	ctx := log.NewContext(context.TODO())
+	ctx = request.WithUser(ctx, model.User{ID: "userid", UserName: "johndoe"})
+	ctx = request.WithUsername(ctx, "johndoe")
+	var beforeRegister time.Time
+
+	BeforeEach(func() {
+		repo = &mockPlayerRepository{}
+		ds := &tests.MockDataStore{MockedPlayer: repo, MockedTranscoding: &tests.MockTranscodingRepo{}}
+		players = NewPlayers(ds)
+		beforeRegister = time.Now()
+	})
+
+	Describe("Register", func() {
+		It("creates a new player when no ID is specified", func() {
+			p, trc, err := players.Register(ctx, "", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).ToNot(BeEmpty())
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(p.Client).To(Equal("client"))
+			Expect(p.UserName).To(Equal("johndoe"))
+			Expect(p.UserAgent).To(Equal("chrome"))
+			Expect(repo.lastSaved).To(Equal(p))
+			Expect(trc).To(BeNil())
+		})
+
+		It("creates a new player if it cannot find any matching player", func() {
+			p, trc, err := players.Register(ctx, "123", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).ToNot(BeEmpty())
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+			Expect(trc).To(BeNil())
+		})
+
+		It("creates a new player if client does not match the one in DB", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client1111", LastSeen: time.Time{}}
+			repo.add(plr)
+			p, trc, err := players.Register(ctx, "123", "client2222", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).ToNot(BeEmpty())
+			Expect(p.ID).ToNot(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(p.Client).To(Equal("client2222"))
+			Expect(trc).To(BeNil())
+		})
+
+		It("finds players by ID", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client", LastSeen: time.Time{}}
+			repo.add(plr)
+			p, trc, err := players.Register(ctx, "123", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).To(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+			Expect(trc).To(BeNil())
+		})
+
+		It("finds player by client and user names when ID is not found", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client", UserName: "johndoe", LastSeen: time.Time{}}
+			repo.add(plr)
+			p, _, err := players.Register(ctx, "999", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).To(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+		})
+
+		It("finds player by client and user names when not ID is provided", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client", UserName: "johndoe", LastSeen: time.Time{}}
+			repo.add(plr)
+			p, _, err := players.Register(ctx, "", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).To(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+		})
+
+		It("finds player by ID and return its transcoding", func() {
+			plr := &model.Player{ID: "123", Name: "A Player", Client: "client", LastSeen: time.Time{}, TranscodingId: "1"}
+			repo.add(plr)
+			p, trc, err := players.Register(ctx, "123", "client", "chrome", "1.2.3.4")
+			Expect(err).ToNot(HaveOccurred())
+			Expect(p.ID).To(Equal("123"))
+			Expect(p.LastSeen).To(BeTemporally(">=", beforeRegister))
+			Expect(repo.lastSaved).To(Equal(p))
+			Expect(trc.ID).To(Equal("1"))
+		})
+	})
+})
+
+type mockPlayerRepository struct {
+	model.PlayerRepository
+	lastSaved *model.Player
+	data      map[string]model.Player
+}
+
+func (m *mockPlayerRepository) add(p *model.Player) {
+	if m.data == nil {
+		m.data = make(map[string]model.Player)
+	}
+	m.data[p.ID] = *p
+}
+
+func (m *mockPlayerRepository) Get(id string) (*model.Player, error) {
+	if p, ok := m.data[id]; ok {
+		return &p, nil
+	}
+	return nil, model.ErrNotFound
+}
+
+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
+		}
+	}
+	return nil, model.ErrNotFound
+}
+
+func (m *mockPlayerRepository) Put(p *model.Player) error {
+	m.lastSaved = p
+	return 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

@@ -0,0 +1,52 @@
+package transcoder
+
+import (
+	"context"
+	"io"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/navidrome/navidrome/log"
+)
+
+type Transcoder interface {
+	Start(ctx context.Context, command, path string, maxBitRate int) (f io.ReadCloser, err error)
+}
+
+func New() Transcoder {
+	return &externalTranscoder{}
+}
+
+type externalTranscoder struct{}
+
+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 transcoding command", "cmd", args)
+	cmd := exec.Command(args[0], args[1:]...) // #nosec
+	cmd.Stderr = os.Stderr
+	if f, err = cmd.StdoutPipe(); err != nil {
+		return
+	}
+	if err = cmd.Start(); err != nil {
+		return
+	}
+
+	go func() { _ = cmd.Wait() }() // prevent zombies
+
+	return
+}
+
+// Path will always be an absolute path
+func createTranscodeCommand(cmd, path string, maxBitRate int) []string {
+	split := strings.Split(cmd, " ")
+	for i, s := range split {
+		s = strings.ReplaceAll(s, "%s", path)
+		s = strings.ReplaceAll(s, "%b", strconv.Itoa(maxBitRate))
+		split[i] = s
+	}
+
+	return split
+}

core/transcoder/transcoder_test.go

@@ -0,0 +1,24 @@
+package transcoder
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestTranscoder(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Transcoder Suite")
+}
+
+var _ = Describe("createTranscodeCommand", func() {
+	It("creates a valid command line", func() {
+		args := createTranscodeCommand("ffmpeg -i %s -b:a %bk mp3 -", "/music library/file.mp3", 123)
+		Expect(args).To(Equal([]string{"ffmpeg", "-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
+	})
+})

core/wire_providers.go

@@ -0,0 +1,23 @@
+package core
+
+import (
+	"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,
+	GetTranscodingCache,
+	GetImageCache,
+	NewArchiver,
+	NewExternalMetadata,
+	NewCacheWarmer,
+	NewPlayers,
+	agents.New,
+	transcoder.New,
+	scrobbler.GetPlayTracker,
+	NewShare,
+)

db/db.go

@@ -0,0 +1,108 @@
+package db
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+
+	_ "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"
+)
+
+var (
+	Driver = "sqlite3"
+	Path   string
+)
+
+func Db() *sql.DB {
+	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)
+		instance, err := sql.Open(Driver, Path)
+		if err != nil {
+			panic(err)
+		}
+		return instance
+	})
+	return instance.(*sql.DB)
+}
+
+func EnsureLatestVersion() {
+	db := Db()
+
+	// Disable foreign_keys to allow re-creating tables in migrations
+	_, err := db.Exec("PRAGMA foreign_keys=off")
+	defer func() {
+		_, err := db.Exec("PRAGMA foreign_keys=on")
+		if err != nil {
+			log.Error("Error re-enabling foreign_keys", err)
+		}
+	}()
+	if err != nil {
+		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)
+		os.Exit(1)
+	}
+	err = goose.Run("up", db, "./")
+	if err != nil {
+		log.Error("Failed to apply new migrations", err)
+		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

@@ -0,0 +1,183 @@
+package migrations
+
+import (
+	"database/sql"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200130083147, Down20200130083147)
+}
+
+func Up20200130083147(tx *sql.Tx) error {
+	log.Info("Creating DB Schema")
+	_, err := tx.Exec(`
+create table if not exists album
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	artist_id varchar(255) default '' not null,
+	cover_art_path varchar(255) default '' not null,
+	cover_art_id varchar(255) default '' not null,
+	artist varchar(255) default '' not null,
+	album_artist varchar(255) default '' not null,
+	year integer default 0 not null,
+	compilation bool default FALSE not null,
+	song_count integer default 0 not null,
+	duration integer default 0 not null,
+	genre varchar(255) default '' not null,
+	created_at datetime,
+	updated_at datetime
+);
+
+create index if not exists album_artist
+	on album (artist);
+
+create index if not exists album_artist_id
+	on album (artist_id);
+
+create index if not exists album_genre
+	on album (genre);
+
+create index if not exists album_name
+	on album (name);
+
+create index if not exists album_year
+	on album (year);
+
+create table if not exists annotation
+(
+	ann_id varchar(255) not null
+		primary key,
+	user_id varchar(255) default '' not null,
+	item_id varchar(255) default '' not null,
+	item_type varchar(255) default '' not null,
+	play_count integer,
+	play_date datetime,
+	rating integer,
+	starred bool default FALSE not null,
+	starred_at datetime,
+	unique (user_id, item_id, item_type)
+);
+
+create index if not exists annotation_play_count
+	on annotation (play_count);
+
+create index if not exists annotation_play_date
+	on annotation (play_date);
+
+create index if not exists annotation_rating
+	on annotation (rating);
+
+create index if not exists annotation_starred
+	on annotation (starred);
+
+create table if not exists artist
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	album_count integer default 0 not null
+);
+
+create index if not exists artist_name
+	on artist (name);
+
+create table if not exists media_file
+(
+	id varchar(255) not null
+		primary key,
+	path varchar(255) default '' not null,
+	title varchar(255) default '' not null,
+	album varchar(255) default '' not null,
+	artist varchar(255) default '' not null,
+	artist_id varchar(255) default '' not null,
+	album_artist varchar(255) default '' not null,
+	album_id varchar(255) default '' not null,
+	has_cover_art bool default FALSE not null,
+	track_number integer default 0 not null,
+	disc_number integer default 0 not null,
+	year integer default 0 not null,
+	size integer default 0 not null,
+	suffix varchar(255) default '' not null,
+	duration integer default 0 not null,
+	bit_rate integer default 0 not null,
+	genre varchar(255) default '' not null,
+	compilation bool default FALSE not null,
+	created_at datetime,
+	updated_at datetime
+);
+
+create index if not exists media_file_album_id
+	on media_file (album_id);
+
+create index if not exists media_file_genre
+	on media_file (genre);
+
+create index if not exists media_file_path
+	on media_file (path);
+
+create index if not exists media_file_title
+	on media_file (title);
+
+create table if not exists playlist
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	comment varchar(255) default '' not null,
+	duration integer default 0 not null,
+	owner varchar(255) default '' not null,
+	public bool default FALSE not null,
+	tracks text not null
+);
+
+create index if not exists playlist_name
+	on playlist (name);
+
+create table if not exists property
+(
+	id varchar(255) not null
+		primary key,
+	value varchar(255) default '' not null
+);
+
+create table if not exists search
+(
+	id varchar(255) not null
+		primary key,
+	"table" varchar(255) default '' not null,
+	full_text varchar(255) default '' not null
+);
+
+create index if not exists search_full_text
+	on search (full_text);
+
+create index if not exists search_table
+	on search ("table");
+
+create table if not exists user
+(
+	id varchar(255) not null
+		primary key,
+	user_name varchar(255) default '' not null
+		unique,
+	name varchar(255) default '' not null,
+	email varchar(255) default '' not null
+		unique,
+	password varchar(255) default '' not null,
+	is_admin bool default FALSE not null,
+	last_login_at datetime,
+	last_access_at datetime,
+	created_at datetime not null,
+	updated_at datetime not null
+);`)
+	return err
+}
+
+func Down20200130083147(tx *sql.Tx) error {
+	return nil
+}