Updating spanish translation

Bumps [@testing-library/user-event](https://github.com/testing-library/user-event) from 12.1.6 to 12.1.7.
- [Release notes](https://github.com/testing-library/user-event/releases)
- [Changelog](https://github.com/testing-library/user-event/blob/master/CHANGELOG.md)
- [Commits](https://github.com/testing-library/user-event/compare/v12.1.6...v12.1.7)

Signed-off-by: dependabot-preview[bot] <support@dependabot.com>

.dockerignore

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

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# Upgrade Prettier to 2.0.4. Reformatted all JS files
+b3f70538a9138bc279a451f4f358605097210d41

.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
+liberapay: deluan
+ko_fi: 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/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,37 @@
+#####################################################
+### 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/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,171 @@
+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@v1
+        with:
+          version: v1.27
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          args: --timeout 2m
+
+  go:
+    name: Test Server
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install taglib
+        run: sudo apt-get install libtag1-dev
+
+      - name: Set up Go 1.15
+        uses: actions/setup-go@v1
+        with:
+          go-version: 1.15
+        id: go
+
+      - name: Check out code into the Go module directory
+        uses: actions/checkout@v2
+
+      - uses: actions/cache@v1
+        id: cache-go
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Download dependencies
+        if: steps.cache-go.outputs.cache-hit != 'true'
+        run: go mod download
+
+      - name: Test
+        run: go test -cover ./... -v
+  js:
+    name: Build JS bundle
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 14
+
+      - uses: actions/cache@v1
+        id: cache-npm
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('ui/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: npm install dependencies
+        run: |
+          cd ui
+          npm ci
+
+      - name: npm check-formatting
+        run: |
+          cd ui
+          npm run check-formatting
+
+      - name: npm build
+        run: |
+          cd ui
+          npm run build
+
+      - uses: actions/upload-artifact@v2
+        with:
+          name: js-bundle
+          path: ui/build
+
+  binaries:
+    name: Binaries
+    needs: [js]
+    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: Run GoReleaser - SNAPSHOT
+        if: startsWith(github.ref, 'refs/tags/') != true
+        uses: docker://deluan/ci-goreleaser:1.15.2-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.15.2-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
+
+  docker:
+    name: Docker images
+    needs: [binaries]
+    runs-on: ubuntu-latest
+    env:
+      DOCKER_IMAGE: ${{secrets.DOCKER_IMAGE}}
+    steps:
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: crazy-max/ghaction-docker-buildx@v1
+        if: env.DOCKER_IMAGE != ''
+        with:
+          buildx-version: latest
+          qemu-version: latest
+
+      - uses: actions/checkout@v1
+        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/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,32 +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:latest
-
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          args: goreleaser release --rm-dist

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

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

.gitignore

@@ -1,5 +1,6 @@
 .DS_Store
 .idea
+.vscode
 .envrc
 /navidrome
 /iTunes*.xml
@@ -9,14 +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.override.yml
+docker-compose.yml
+navidrome.db-shm
+navidrome.db-wal
+tags
+

.golangci.yml

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

.goreleaser.yml

@@ -1,27 +1,13 @@
 # GoReleaser config
+project_name: navidrome
 
 before:
   hooks:
-    - go get -u github.com/go-bindata/go-bindata/...
+    - go-bindata -fs -prefix resources -tags embed -ignore="\\\*.go" -pkg resources -o resources/embedded_gen.go resources/...
     - go-bindata -fs -prefix ui/build -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/...
-    - git checkout .
 
 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:
@@ -30,15 +16,63 @@ builds:
       - amd64
     flags:
       - -tags=embed
+    ldflags:
+      - "-extldflags '-static -lz'"
+      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_linux_386
+    env:
+      - CGO_ENABLED=1
+    goos:
+      - linux
+    goarch:
+      - 386
+    flags:
+      - -tags=embed
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+
+  - 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
+    ldflags:
+      - "-extldflags '-static'"
+      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/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
+    ldflags:
+      - "-extldflags '-static'"
+      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_windows_i686
     env:
       - CGO_ENABLED=1
       - CC=i686-w64-mingw32-gcc
       - CXX=i686-w64-mingw32-g++
+      - PKG_CONFIG_PATH=/mingw32/lib/pkgconfig
     goos:
       - windows
     goarch:
@@ -47,13 +81,14 @@ builds:
       - -tags=embed
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
 
   - id: navidrome_windows_x64
     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:
@@ -62,24 +97,45 @@ builds:
       - -tags=embed
     ldflags:
       - "-extldflags '-static'"
-      - -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Tag}}
+      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/navidrome/consts.gitTag={{.Version}}
+
+  - id: navidrome_darwin
+    env:
+      - CGO_ENABLED=1
+      - CC=o64-clang
+      - CXX=o64-clang++
+      - PKG_CONFIG_PATH=/darwin/lib/pkgconfig
+    goos:
+      - darwin
+    goarch:
+      - amd64
+    flags:
+      - -tags=embed
+    ldflags:
+      - -s -w -X github.com/deluan/navidrome/consts.gitSha={{.ShortCommit}} -X github.com/deluan/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:'
+      - "^docs:"

.nvmrc

@@ -1 +1 @@
-v13.7.0
+v14

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, set with ND_MUSICFOLDER configuration |
-| `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 `fromYear` and `toYear` parameters |
-| ||
-| _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`               | No Transcoding/Downsampling support (for now)|
-| `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.

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,82 +1,110 @@
-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)
 
 GIT_SHA=$(shell git rev-parse --short HEAD)
+GIT_TAG=$(shell git describe --tags `git rev-list --tags --max-count=1`)
+
+## Default target just build the Go project.
+default:
+	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=master"
+.PHONY: default
 
-.PHONY: dev
 dev: check_env
-	@goreman -f Procfile.dev -b 4533 start
+	npx foreman -j Procfile.dev -p 4533 start
+.PHONY: dev
 
-.PHONY: server
 server: check_go_env
 	@reflex -d none -c reflex.conf
+.PHONY: server
+
+wire: check_go_env
+	wire ./...
+.PHONY: wire
 
-.PHONY: watch
 watch: check_go_env
 	ginkgo watch -notify ./...
+.PHONY: watch
 
-.PHONY: test
 test: check_go_env
 	go test ./... -v
-#	@(cd ./ui && npm test -- --watchAll=false)
+.PHONY: test
 
-.PHONY: testall
 testall: check_go_env test
 	@(cd ./ui && npm test -- --watchAll=false)
+.PHONY: testall
 
+update-snapshots: check_go_env
+	UPDATE_SNAPSHOTS=true ginkgo ./server/subsonic/...
+.PHONY: update-snapshots
+
+migration:
+	@if [ -z "${name}" ]; then echo "Usage: make migration name=name_of_migration_file"; exit 1; fi
+	goose -dir db/migrations create ${name}
+.PHONY: migration
+
+setup: download-deps
+	@echo Installing tools from tools.go
+	@cat tools.go | grep _ | awk -F'"' '{print $$2}' | xargs -tI % go install %
 .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
+
+download-deps:
+	@echo Download Go dependencies
+	@go mod download
+	@echo Download Node dependencies
 	@(cd ./ui && npm ci)
+.PHONY: download-deps
 
-.PHONY: static
-static:
-	cd static && go-bindata -fs -prefix "static" -nocompress -ignore="\\\*.go" -pkg static .
+setup-dev: setup setup-git
+	@echo Installing golangci-lint
+	@which golangci-lint || (echo "Installing GolangCI-Lint" && cd .. && GO111MODULE=on go get github.com/golangci/golangci-lint/cmd/golangci-lint@v1.27.0)
+.PHONY: setup-dev
 
-Jamstash-master:
-	wget -N https://github.com/tsquillario/Jamstash/archive/master.zip
-	unzip -o master.zip
-	rm master.zip
+setup-git:
+	@echo Setting up git hooks
+	@mkdir -p .git/hooks
+	@(cd .git/hooks && ln -sf ../../git/* .)
+.PHONY: setup-git
 
-.PHONE: check_env
 check_env: check_go_env check_node_env
+.PHONY: check_env
 
-.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)
+	@go version | grep -q $(GO_VERSION) || (echo "\nERROR: Please upgrade your GO version\nThis project requires version $(GO_VERSION)"; exit 1)
+.PHONY: check_go_env
 
-.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)
+.PHONY: check_node_env
 
-.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"
+	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT"
+.PHONY: build
 
-.PHONY: buildall
 buildall: check_env
 	@(cd ./ui && npm run build)
+	go-bindata -fs -prefix "resources" -tags embed -ignore="\\\*.go" -pkg resources -o resources/embedded_gen.go resources/...
 	go-bindata -fs -prefix "ui/build" -tags embed -nocompress -pkg assets -o assets/embedded_gen.go ui/build/...
-	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=master" -tags=embed
+	go build -ldflags="-X github.com/deluan/navidrome/consts.gitSha=$(GIT_SHA) -X github.com/deluan/navidrome/consts.gitTag=$(GIT_TAG)-SNAPSHOT" -tags=embed
+.PHONY: buildall
+
+pre-push:
+	golangci-lint run -v
+
+	@echo
+	make test
+.PHONY: pre-push
 
-.PHONY: release
 release:
 	@if [[ ! "${V}" =~ ^[0-9]+\.[0-9]+\.[0-9]+.*$$ ]]; then echo "Usage: make release V=X.X.X"; exit 1; fi
 	go mod tidy
 	@if [ -n "`git status -s`" ]; then echo "\n\nThere are pending changes. Please commit or stash first"; exit 1; fi
-	make test
+	make pre-push
 	git tag v${V}
-	git push origin v${V}
+	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
+snapshot:
+	 docker run -it -v $(PWD):/workspace -w /workspace deluan/ci-goreleaser:1.15.2-1 goreleaser release --rm-dist --skip-publish --snapshot
+.PHONY: snapshot

README.md

@@ -1,133 +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)
-[![Join the Chat](https://img.shields.io/discord/671335427726114836?style=for-the-badge)](https://discord.gg/xh7j7yF)
+[![Last Release](https://img.shields.io/github/v/release/deluan/navidrome?label=latest&style=flat-square)](https://github.com/deluan/navidrome/releases)
+[![Build](https://img.shields.io/github/workflow/status/deluan/navidrome/Build?style=flat-square)](https://github.com/deluan/navidrome/actions)
+[![Downloads](https://img.shields.io/github/downloads/deluan/navidrome/total)](https://github.com/deluan/navidrome/releases/latest)
+[![Docker Pulls](https://img.shields.io/docker/pulls/deluan/navidrome?style=flat-square)](https://hub.docker.com/r/deluan/navidrome)
+[![Dev Chat](https://img.shields.io/discord/671335427726114836?label=chat&style=flat-square)](https://discord.gg/xh7j7yF)
+[![Subreddit](https://img.shields.io/reddit/subreddit-subscribers/navidrome?style=flat-square)](https://www.reddit.com/r/navidrome/)
+[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0-ff69b4.svg)](code_of_conduct.md)
+
+## [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. 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/)
-- Transcoding/Downsampling on-the-fly (WIP. Experimental support is available)
-
-
-## 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: 
-
-- Integrated music player
-- Last.FM integration
-- Pre-build binaries for Raspberry Pi
-- Smart/dynamic playlists (similar to iTunes)
-- Support for audiobooks (bookmarking)
-- Jukebox mode
-- Sharing links to albums/songs/playlists
-- Podcasts
-
+please file a [GitHub issue](https://github.com/deluan/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-built 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.
-You may find the latest static build for your platform here: https://johnvansickle.com/ffmpeg/ 
-
-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"
-      - "/path/to/your/music/folder:/music"
-```
-
-To get the cutting-edge, latest version from master, use the image `deluan/navidrome:develop`
-
-### 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` executable binary 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/deluan/navidrome/master/.github/screenshots/ss-mobile-login.png">
+    <img height="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-player.png">
+    <img height="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-mobile-album-view.png">
+    <img width="550" src="https://raw.githubusercontent.com/deluan/navidrome/master/.github/screenshots/ss-desktop-player.png">
 </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

@@ -6,7 +6,6 @@ import (
 	"net/http"
 	"sync"
 
-	"github.com/deluan/navidrome/consts"
 	"github.com/deluan/navidrome/log"
 )
 
@@ -14,7 +13,7 @@ var once sync.Once
 
 func AssetFile() http.FileSystem {
 	once.Do(func() {
-		log.Warn("Using external assets from " + consts.UIAssetsLocalPath)
+		log.Warn("Using external assets from 'ui/build' folder")
 	})
-	return http.Dir(consts.UIAssetsLocalPath)
+	return http.Dir("ui/build")
 }

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,97 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/consts"
+	"github.com/deluan/navidrome/db"
+	"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) {
+			startServer()
+		},
+		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 startServer() {
+	db.EnsureLatestVersion()
+
+	subsonic, err := CreateSubsonicAPIRouter()
+	if err != nil {
+		panic(fmt.Sprintf("Could not create the Subsonic API router. Aborting! err=%v", err))
+	}
+	a := CreateServer(conf.Server.MusicFolder)
+	a.MountRouter(consts.URLPathSubsonicAPI, subsonic)
+	a.MountRouter(consts.URLPathUI, CreateAppRouter())
+	a.Run(fmt.Sprintf("%s:%d", conf.Server.Address, conf.Server.Port))
+}
+
+// TODO: Implemement some struct tags to map flags to viper
+func 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/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/log"
+	"github.com/spf13/cobra"
+)
+
+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() {
+	scanner := CreateScanner(conf.Server.MusicFolder)
+	err := scanner.RescanAll(fullRescan)
+	if err != nil {
+		log.Error("Error scanning media folder", "folder", conf.Server.MusicFolder, err)
+	}
+	if fullRescan {
+		log.Info("Finished full rescan")
+	} else {
+		log.Info("Finished rescan")
+	}
+}

cmd/wire_gen.go

@@ -0,0 +1,59 @@
+// Code generated by Wire. DO NOT EDIT.
+
+//go:generate wire
+//+build !wireinject
+
+package cmd
+
+import (
+	"github.com/deluan/navidrome/core"
+	"github.com/deluan/navidrome/core/transcoder"
+	"github.com/deluan/navidrome/persistence"
+	"github.com/deluan/navidrome/scanner"
+	"github.com/deluan/navidrome/server"
+	"github.com/deluan/navidrome/server/app"
+	"github.com/deluan/navidrome/server/subsonic"
+	"github.com/deluan/navidrome/server/subsonic/engine"
+	"github.com/google/wire"
+)
+
+// Injectors from wire_injectors.go:
+
+func CreateServer(musicFolder string) *server.Server {
+	dataStore := persistence.New()
+	scannerScanner := scanner.New(dataStore)
+	serverServer := server.New(scannerScanner, dataStore)
+	return serverServer
+}
+
+func CreateScanner(musicFolder string) *scanner.Scanner {
+	dataStore := persistence.New()
+	scannerScanner := scanner.New(dataStore)
+	return scannerScanner
+}
+
+func CreateAppRouter() *app.Router {
+	dataStore := persistence.New()
+	router := app.New(dataStore)
+	return router
+}
+
+func CreateSubsonicAPIRouter() (*subsonic.Router, error) {
+	dataStore := persistence.New()
+	artworkCache := core.NewImageCache()
+	artwork := core.NewArtwork(dataStore, artworkCache)
+	nowPlayingRepository := engine.NewNowPlayingRepository()
+	listGenerator := engine.NewListGenerator(dataStore, nowPlayingRepository)
+	playlists := engine.NewPlaylists(dataStore)
+	transcoderTranscoder := transcoder.New()
+	transcodingCache := core.NewTranscodingCache()
+	mediaStreamer := core.NewMediaStreamer(dataStore, transcoderTranscoder, transcodingCache)
+	archiver := core.NewArchiver(dataStore)
+	players := engine.NewPlayers(dataStore)
+	router := subsonic.New(artwork, listGenerator, playlists, mediaStreamer, archiver, players, dataStore)
+	return router, nil
+}
+
+// wire_injectors.go:
+
+var allProviders = wire.NewSet(engine.Set, core.Set, scanner.New, subsonic.New, app.New, persistence.New)

cmd/wire_injectors.go

@@ -1,19 +1,21 @@
 //+build wireinject
 
-package main
+package cmd
 
 import (
-	"github.com/deluan/navidrome/engine"
+	"github.com/deluan/navidrome/core"
 	"github.com/deluan/navidrome/persistence"
 	"github.com/deluan/navidrome/scanner"
 	"github.com/deluan/navidrome/server"
 	"github.com/deluan/navidrome/server/app"
 	"github.com/deluan/navidrome/server/subsonic"
+	"github.com/deluan/navidrome/server/subsonic/engine"
 	"github.com/google/wire"
 )
 
 var allProviders = wire.NewSet(
 	engine.Set,
+	core.Set,
 	scanner.New,
 	subsonic.New,
 	app.New,
@@ -27,10 +29,16 @@ func CreateServer(musicFolder string) *server.Server {
 	))
 }
 
-func CreateAppRouter(path string) *app.Router {
+func CreateScanner(musicFolder string) *scanner.Scanner {
+	panic(wire.Build(
+		allProviders,
+	))
+}
+
+func CreateAppRouter() *app.Router {
 	panic(wire.Build(allProviders))
 }
 
-func CreateSubsonicAPIRouter() *subsonic.Router {
+func CreateSubsonicAPIRouter() (*subsonic.Router, error) {
 	panic(wire.Build(allProviders))
 }

conf/configuration.go

@@ -1,96 +1,146 @@
 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/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
+	SessionTimeout          time.Duration
+	BaseURL                 string
+	UILoginBackgroundURL    string
+	EnableTranscodingConfig 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
+	IgnoredArticles  string
+	IndexGroups      string
+	ProbeCommand     string
+	CoverArtPriority string
+	CoverJpegQuality int
+	UIWelcomeMessage string
+	GATrackingID     string
+	AuthRequestLimit int
+	AuthWindowLength time.Duration
 
-	EnableDownsampling bool   `default:"false"`
-	MaxBitRate         int    `default:"0"`
-	DownsampleCommand  string `default:"ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -f mp3 -"`
-	ProbeCommand       string `default:"ffmpeg -i %s -f ffmetadata"`
-	ScanInterval       string `default:"1m"`
+	Scanner scannerOptions
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
-	DevDisableBanner bool `default:"false"`
-	DevLogSourceLine bool `default:"false"`
+	DevLogSourceLine           bool
+	DevAutoCreateAdminPassword string
 }
 
-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
 }
 
-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.SetLevelString(Server.LogLevel)
-	log.SetLogSourceLine(Server.DevLogSourceLine)
-	log.Trace("Loaded configuration", "file", confFile, "config", fmt.Sprintf("%#v", Server))
+var Server = &configOptions{}
+
+func LoadFromFile(confFile string) {
+	viper.SetConfigFile(confFile)
+	Load()
 }
 
 func Load() {
-	LoadFromFile(consts.LocalConfigFile)
+	err := viper.Unmarshal(&Server)
+	if err != nil {
+		fmt.Println("Error parsing config:", err)
+		os.Exit(1)
+	}
+	err = os.MkdirAll(Server.DataFolder, os.ModePerm)
+	if err != nil {
+		fmt.Println("Error creating data path:", "path", Server.DataFolder, err)
+		os.Exit(1)
+	}
+	Server.ConfigFile = viper.GetViper().ConfigFileUsed()
+	if Server.DbPath == "" {
+		Server.DbPath = filepath.Join(Server.DataFolder, consts.DefaultDbPath)
+	}
+
+	log.SetLevelString(Server.LogLevel)
+	log.SetLogSourceLine(Server.DevLogSourceLine)
+	log.Debug("Loaded configuration", "file", Server.ConfigFile, "config", fmt.Sprintf("%#v", Server))
+}
+
+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", time.Minute)
+	viper.SetDefault("baseurl", "")
+	viper.SetDefault("uiloginbackgroundurl", "https://source.unsplash.com/random/1600x900?music")
+	viper.SetDefault("enabletranscodingconfig", false)
+	viper.SetDefault("transcodingcachesize", "100MB")
+	viper.SetDefault("imagecachesize", "100MB")
+	viper.SetDefault("autoimportplaylists", true)
+
+	// Config options only valid for file/env configuration
+	viper.SetDefault("searchfullstring", 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("gatrackingid", "")
+	viper.SetDefault("authrequestlimit", 5)
+	viper.SetDefault("authwindowlength", 20*time.Second)
+
+	viper.SetDefault("scanner.extractor", "taglib")
+
+	// DevFlags. These are used to enable/disable debugging and incomplete features
+	viper.SetDefault("devlogsourceline", false)
+	viper.SetDefault("devautocreateadminpassword", "")
+	viper.SetDefault("devoldscanner", false)
+}
+
+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 cfgFile != "" && err != nil {
+		fmt.Println("Navidrome could not open config file: ", err)
+		os.Exit(1)
+	}
+}
+
+func getConfigFile(cfgFile string) string {
+	if cfgFile != "" {
+		return cfgFile
+	}
+	return os.Getenv("ND_CONFIGFILE")
 }

consts/banner.go

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

consts/consts.go

@@ -1,16 +1,69 @@
 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"
+	JWTSecretKey          = "JWTSecret"
+	JWTIssuer             = "ND"
+	DefaultSessionTimeout = 24 * time.Hour
 
-	UIAssetsLocalPath = "ui/build"
+	DevInitialUserName = "admin"
+	DevInitialName     = "Dev Admin"
+
+	URLPathUI          = "/app"
+	URLPathSubsonicAPI = "/rest"
+
+	RequestThrottleBacklogLimit   = 100
+	RequestThrottleBacklogTimeout = time.Minute
+
+	I18nFolder   = "i18n"
+	SkipScanFile = ".ndignore"
+
+	PlaceholderAlbumArt = "navidrome-600x600.png"
+)
+
+// Cache options
+const (
+	TranscodingCacheDir             = "cache/transcoding"
+	DefaultTranscodingCacheMaxItems = 0 // Unlimited
+
+	ImageCacheDir             = "cache/images"
+	DefaultImageCacheMaxItems = 0 // Unlimited
+
+	DefaultCacheSize            = 100 * 1024 * 1024 // 100MB
+	DefaultCacheCleanUpInterval = 10 * time.Minute
+)
+
+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]"
 )

consts/mime_types.go

@@ -8,7 +8,6 @@ func init() {
 		".ogg":  "audio/ogg",
 		".oga":  "audio/ogg",
 		".opus": "audio/ogg",
-		".ogx":  "application/ogg",
 		".aac":  "audio/mp4",
 		".m4a":  "audio/mp4",
 		".m4b":  "audio/mp4",
@@ -18,23 +17,15 @@ func init() {
 		".ape":  "audio/x-monkeys-audio",
 		".mpc":  "audio/x-musepack",
 		".shn":  "audio/x-shn",
-		".flv":  "video/x-flv",
-		".avi":  "video/avi",
-		".mpg":  "video/mpeg",
-		".mpeg": "video/mpeg",
-		".mp4":  "video/mp4",
-		".m4v":  "video/x-m4v",
-		".mkv":  "video/x-matroska",
-		".mov":  "video/quicktime",
-		".wmv":  "video/x-ms-wmv",
-		".ogv":  "video/ogg",
-		".divx": "video/divx",
-		".m2ts": "video/MP2T",
-		".ts":   "video/MP2T",
-		".webm": "video/webm",
+		".aif":  "audio/x-aiff",
+		".aiff": "audio/x-aiff",
+		".m3u":  "audio/x-mpegurl",
+		".pls":  "audio/x-scpls",
+		".dsf":  "audio/dsd",
 		".gif":  "image/gif",
 		".jpg":  "image/jpeg",
 		".jpeg": "image/jpeg",
+		".webp": "image/webp",
 		".png":  "image/png",
 		".bmp":  "image/bmp",
 	}

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/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,48 @@
+# 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
+AssertPathExists=/var/lib/navidrome
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+User=navidrome
+Group=navidrome
+Type=simple
+ExecStart=/usr/bin/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
+DevicePolicy=closed
+NoNewPrivileges=yes
+PrivateTmp=yes
+PrivateUsers=yes
+ProtectControlGroups=yes
+ProtectKernelModules=yes
+ProtectKernelTunables=yes
+RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
+RestrictNamespaces=yes
+RestrictRealtime=yes
+SystemCallFilter=~@clock @debug @module @mount @obsolete @privileged @reboot @setuid @swap
+ReadWritePaths=/var/lib/navidrome
+
+# 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/archiver.go

@@ -0,0 +1,110 @@
+package core
+
+import (
+	"archive/zip"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/Masterminds/squirrel"
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/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).FindByAlbum(id)
+	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, 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,209 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"image"
+	_ "image/gif"
+	"image/jpeg"
+	_ "image/png"
+	"io"
+	"os"
+	"strings"
+	"time"
+
+	_ "golang.org/x/image/webp"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/consts"
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/resources"
+	"github.com/deluan/navidrome/utils"
+	"github.com/dhowden/tag"
+	"github.com/disintegration/imaging"
+)
+
+type Artwork interface {
+	Get(ctx context.Context, id string, size int, out io.Writer) error
+}
+
+type ArtworkCache FileCache
+
+func NewArtwork(ds model.DataStore, cache ArtworkCache) Artwork {
+	return &artwork{ds: ds, cache: cache}
+}
+
+type artwork struct {
+	ds    model.DataStore
+	cache FileCache
+}
+
+type imageInfo struct {
+	c          *artwork
+	path       string
+	size       int
+	lastUpdate time.Time
+}
+
+func (ci *imageInfo) String() string {
+	return fmt.Sprintf("%s.%d.%s.%d", ci.path, ci.size, ci.lastUpdate.Format(time.RFC3339Nano), conf.Server.CoverJpegQuality)
+}
+
+func (c *artwork) Get(ctx context.Context, id string, size int, out io.Writer) error {
+	path, lastUpdate, err := c.getImagePath(ctx, id)
+	if err != nil && err != model.ErrNotFound {
+		return err
+	}
+
+	info := &imageInfo{
+		c:          c,
+		path:       path,
+		size:       size,
+		lastUpdate: lastUpdate,
+	}
+
+	r, err := c.cache.Get(ctx, info)
+	if err != nil {
+		log.Error(ctx, "Error accessing image cache", "path", path, "size", size, err)
+		return err
+	}
+	defer r.Close()
+
+	_, err = io.Copy(out, r)
+	return err
+}
+
+func (c *artwork) getImagePath(ctx context.Context, id string) (path string, lastUpdated time.Time, err error) {
+	// If id is an album cover ID
+	if strings.HasPrefix(id, "al-") {
+		log.Trace(ctx, "Looking for album art", "id", id)
+		id = strings.TrimPrefix(id, "al-")
+		var al *model.Album
+		al, err = c.ds.Album(ctx).Get(id)
+		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 cover id
+	var mf *model.MediaFile
+	mf, err = c.ds.MediaFile(ctx).Get(id)
+
+	// If it is not, may be an albumId
+	if err == model.ErrNotFound {
+		return c.getImagePath(ctx, "al-"+id)
+	}
+	if err != nil {
+		return
+	}
+
+	// If it is a mediaFile and it has cover art, return it
+	if mf.HasCoverArt {
+		return mf.Path, mf.UpdatedAt, nil
+	}
+
+	// if the mediaFile does not have a coverArt, fallback to the album cover
+	log.Trace(ctx, "Media file does not contain art. Falling back to album art", "id", id, "albumId", "al-"+mf.AlbumID)
+	return c.getImagePath(ctx, "al-"+mf.AlbumID)
+}
+
+func (c *artwork) getArtwork(ctx context.Context, path string, size int) (reader io.Reader, err error) {
+	defer func() {
+		if err != nil {
+			log.Warn(ctx, "Error extracting image", "path", path, "size", size, err)
+			reader, err = resources.AssetFile().Open(consts.PlaceholderAlbumArt)
+		}
+	}()
+
+	if path == "" {
+		return nil, errors.New("empty path given for artwork")
+	}
+
+	var data []byte
+	if utils.IsAudioFile(path) {
+		data, err = readFromTag(path)
+	} else {
+		data, err = readFromFile(path)
+	}
+
+	if err != nil {
+		return
+	} else if size > 0 {
+		data, err = resizeImage(bytes.NewReader(data), size)
+	}
+
+	// Confirm the image is valid. Costly, but necessary
+	_, _, err = image.Decode(bytes.NewReader(data))
+	if err == nil {
+		reader = bytes.NewReader(data)
+	}
+
+	return
+}
+
+func resizeImage(reader io.Reader, size int) ([]byte, error) {
+	img, _, err := image.Decode(reader)
+	if err != nil {
+		return nil, err
+	}
+	m := imaging.Resize(img, size, size, imaging.Lanczos)
+	buf := new(bytes.Buffer)
+	err = jpeg.Encode(buf, m, &jpeg.Options{Quality: conf.Server.CoverJpegQuality})
+	return buf.Bytes(), err
+}
+
+func readFromTag(path string) ([]byte, 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 picture.Data, nil
+}
+
+func readFromFile(path string) ([]byte, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	defer f.Close()
+	var buf bytes.Buffer
+	if _, err := buf.ReadFrom(f); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func NewImageCache() ArtworkCache {
+	return NewFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems,
+		func(ctx context.Context, arg fmt.Stringer) (io.Reader, error) {
+			info := arg.(*imageInfo)
+			reader, err := info.c.getArtwork(ctx, info.path, info.size)
+			if err != nil {
+				log.Error(ctx, "Error loading artwork art", "path", info.path, "size", info.size, err)
+				return nil, err
+			}
+			return reader, nil
+		})
+}

core/artwork_test.go

@@ -0,0 +1,142 @@
+package core
+
+import (
+	"bytes"
+	"context"
+	"image"
+	"io/ioutil"
+	"os"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/persistence"
+	. "github.com/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 = &persistence.MockDataStore{MockedTranscoding: &mockTranscodingRepository{}}
+		ds.Album(ctx).(*persistence.MockAlbum).SetData(`[{"id": "222", "coverArtId": "123", "coverArtPath":"tests/fixtures/test.mp3"}, {"id": "333", "coverArtId": ""}, {"id": "444", "coverArtId": "444", "coverArtPath": "tests/fixtures/cover.jpg"}]`)
+		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "albumId": "222", "path": "tests/fixtures/test.mp3", "hasCoverArt": true, "updatedAt":"2020-04-02T21:29:31.6377Z"},{"id": "456", "albumId": "222", "path": "tests/fixtures/test.ogg", "hasCoverArt": false, "updatedAt":"2020-04-02T21:29:31.6377Z"}]`)
+	})
+
+	Context("Cache is configured", func() {
+		BeforeEach(func() {
+			conf.Server.DataFolder, _ = ioutil.TempDir("", "file_caches")
+			conf.Server.ImageCacheSize = "100MB"
+			cache := NewImageCache()
+			Eventually(func() bool { return cache.Ready() }).Should(BeTrue())
+			artwork = NewArtwork(ds, cache)
+		})
+
+		AfterEach(func() {
+			os.RemoveAll(conf.Server.DataFolder)
+		})
+
+		It("retrieves the external artwork art for an album", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(artwork.Get(ctx, "al-444", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+		})
+
+		It("retrieves the embedded artwork art for an album", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(artwork.Get(ctx, "al-222", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+		})
+
+		It("returns the default artwork if album does not have artwork", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(artwork.Get(ctx, "al-333", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("png"))
+		})
+
+		It("returns the default artwork if album is not found", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(artwork.Get(ctx, "al-0101", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("png"))
+		})
+
+		It("retrieves the original artwork art from a media_file", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(artwork.Get(ctx, "123", 0, buf)).To(BeNil())
+
+			img, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			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))
+		})
+
+		It("retrieves the album artwork art if media_file does not have one", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(artwork.Get(ctx, "456", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+		})
+
+		It("retrieves the album artwork by album id", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(artwork.Get(ctx, "222", 0, buf)).To(BeNil())
+
+			_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			Expect(err).To(BeNil())
+			Expect(format).To(Equal("jpeg"))
+		})
+
+		It("resized artwork art as requested", func() {
+			buf := new(bytes.Buffer)
+
+			Expect(artwork.Get(ctx, "123", 200, buf)).To(BeNil())
+
+			img, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
+			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))
+		})
+
+		Context("Errors", func() {
+			It("returns err if gets error from album table", func() {
+				ds.Album(ctx).(*persistence.MockAlbum).SetError(true)
+				buf := new(bytes.Buffer)
+
+				Expect(artwork.Get(ctx, "al-222", 0, buf)).To(MatchError("Error!"))
+			})
+
+			It("returns err if gets error from media_file table", func() {
+				ds.MediaFile(ctx).(*persistence.MockMediaFile).SetError(true)
+				buf := new(bytes.Buffer)
+
+				Expect(artwork.Get(ctx, "123", 0, buf)).To(MatchError("Error!"))
+			})
+		})
+	})
+})

core/auth/auth.go

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

core/auth/auth_test.go

@@ -0,0 +1,55 @@
+package auth_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/deluan/navidrome/core/auth"
+	"github.com/deluan/navidrome/log"
+	"github.com/dgrijalva/jwt-go"
+	. "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"
+
+var _ = Describe("Auth", func() {
+	BeforeEach(func() {
+		auth.JwtSecret = []byte(testJWTSecret)
+	})
+	Context("Validate", func() {
+		It("returns error with an invalid JWT token", func() {
+			_, err := auth.Validate("invalid.token")
+			Expect(err).To(Not(BeNil()))
+		})
+
+		It("returns the claims from a valid JWT token", func() {
+			token := jwt.New(jwt.SigningMethodHS256)
+			claims := token.Claims.(jwt.MapClaims)
+			claims["iss"] = "issuer"
+			claims["exp"] = time.Now().Add(1 * time.Minute).Unix()
+			tokenStr, _ := token.SignedString(auth.JwtSecret)
+
+			decodedClaims, err := auth.Validate(tokenStr)
+			Expect(err).To(BeNil())
+			Expect(decodedClaims["iss"]).To(Equal("issuer"))
+		})
+
+		It("returns ErrExpired if the `exp` field is in the past", func() {
+			token := jwt.New(jwt.SigningMethodHS256)
+			claims := token.Claims.(jwt.MapClaims)
+			claims["iss"] = "issuer"
+			claims["exp"] = time.Now().Add(-1 * time.Minute).Unix()
+			tokenStr, _ := token.SignedString(auth.JwtSecret)
+
+			_, err := auth.Validate(tokenStr)
+			Expect(err).To(MatchError("Token is expired"))
+		})
+	})
+})

core/common.go

@@ -0,0 +1,15 @@
+package core
+
+import (
+	"context"
+
+	"github.com/deluan/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/deluan/navidrome/log"
+	"github.com/deluan/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestEngine(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Core Suite")
+}

core/file_caches.go

@@ -0,0 +1,195 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/consts"
+	"github.com/deluan/navidrome/log"
+	"github.com/djherbis/fscache"
+	"github.com/dustin/go-humanize"
+)
+
+type ReadFunc func(ctx context.Context, arg fmt.Stringer) (io.Reader, error)
+
+type FileCache interface {
+	Get(ctx context.Context, arg fmt.Stringer) (*CachedStream, error)
+	Ready() bool
+}
+
+func NewFileCache(name, cacheSize, cacheFolder string, maxItems int, getReader ReadFunc) *fileCache {
+	fc := &fileCache{
+		name:        name,
+		cacheSize:   cacheSize,
+		cacheFolder: filepath.FromSlash(cacheFolder),
+		maxItems:    maxItems,
+		getReader:   getReader,
+		mutex:       &sync.RWMutex{},
+	}
+
+	go func() {
+		cache, err := newFSCache(fc.name, fc.cacheSize, fc.cacheFolder, fc.maxItems)
+		fc.mutex.Lock()
+		defer fc.mutex.Unlock()
+		if err == nil {
+			fc.cache = cache
+			fc.disabled = cache == nil
+		}
+		fc.ready = true
+		if fc.disabled {
+			log.Debug("Cache disabled", "cache", fc.name, "size", fc.cacheSize)
+		}
+	}()
+
+	return fc
+}
+
+type fileCache struct {
+	name        string
+	cacheSize   string
+	cacheFolder string
+	maxItems    int
+	cache       fscache.Cache
+	getReader   ReadFunc
+	disabled    bool
+	ready       bool
+	mutex       *sync.RWMutex
+}
+
+func (fc *fileCache) Ready() bool {
+	fc.mutex.RLock()
+	defer fc.mutex.RUnlock()
+	return fc.ready
+}
+
+func (fc *fileCache) available(ctx context.Context) bool {
+	fc.mutex.RLock()
+	defer fc.mutex.RUnlock()
+
+	if !fc.ready {
+		log.Debug(ctx, "Cache not initialized yet", "cache", fc.name)
+	}
+
+	return fc.ready && !fc.disabled
+}
+
+func (fc *fileCache) Get(ctx context.Context, arg fmt.Stringer) (*CachedStream, error) {
+	if !fc.available(ctx) {
+		reader, err := fc.getReader(ctx, arg)
+		if err != nil {
+			return nil, err
+		}
+		return &CachedStream{Reader: reader}, nil
+	}
+
+	key := arg.String()
+	r, w, err := fc.cache.Get(key)
+	if err != nil {
+		return nil, err
+	}
+
+	cached := w == nil
+
+	if !cached {
+		log.Trace(ctx, "Cache MISS", "cache", fc.name, "key", key)
+		reader, err := fc.getReader(ctx, arg)
+		if err != nil {
+			return nil, err
+		}
+		go copyAndClose(ctx, w, reader)
+	}
+
+	// If it is in the cache, check if the stream is done being written. If so, return a ReaderSeeker
+	if cached {
+		size := getFinalCachedSize(r)
+		if size >= 0 {
+			log.Trace(ctx, "Cache HIT", "cache", fc.name, "key", key, "size", size)
+			sr := io.NewSectionReader(r, 0, size)
+			return &CachedStream{
+				Reader: sr,
+				Seeker: sr,
+				Cached: true,
+			}, nil
+		} else {
+			log.Trace(ctx, "Cache HIT", "cache", fc.name, "key", key)
+		}
+	}
+
+	// All other cases, just return a Reader, without Seek capabilities
+	return &CachedStream{Reader: r, Cached: cached}, nil
+}
+
+type CachedStream struct {
+	io.Reader
+	io.Seeker
+	Cached bool
+}
+
+func (s *CachedStream) Seekable() bool { return s.Seeker != nil }
+func (s *CachedStream) Close() error {
+	if c, ok := s.Reader.(io.Closer); ok {
+		return c.Close()
+	}
+	return nil
+}
+
+func getFinalCachedSize(r fscache.ReadAtCloser) int64 {
+	cr, ok := r.(*fscache.CacheReader)
+	if ok {
+		size, final, err := cr.Size()
+		if final && err == nil {
+			return size
+		}
+	}
+	return -1
+}
+
+func copyAndClose(ctx context.Context, w io.WriteCloser, r io.Reader) {
+	_, err := io.Copy(w, r)
+	if err != nil {
+		log.Error(ctx, "Error copying data to cache", err)
+	}
+	if c, ok := r.(io.Closer); ok {
+		err = c.Close()
+		if err != nil {
+			log.Error(ctx, "Error closing source stream", err)
+		}
+	}
+	err = w.Close()
+	if err != nil {
+		log.Error(ctx, "Error closing cache writer", err)
+	}
+}
+
+func newFSCache(name, cacheSize, cacheFolder string, maxItems int) (fscache.Cache, error) {
+	size, err := humanize.ParseBytes(cacheSize)
+	if err != nil {
+		log.Error("Invalid cache size. Using default size", "cache", name, "size", cacheSize,
+			"defaultSize", humanize.Bytes(consts.DefaultCacheSize))
+		size = consts.DefaultCacheSize
+	}
+	if size == 0 {
+		log.Warn(fmt.Sprintf("%s cache disabled", name))
+		return nil, nil
+	}
+
+	start := time.Now()
+	lru := fscache.NewLRUHaunter(maxItems, int64(size), consts.DefaultCacheCleanUpInterval)
+	h := fscache.NewLRUHaunterStrategy(lru)
+	cacheFolder = filepath.Join(conf.Server.DataFolder, cacheFolder)
+
+	log.Info(fmt.Sprintf("Creating %s cache", name), "path", cacheFolder, "maxSize", humanize.Bytes(size))
+	fs, err := fscache.NewFs(cacheFolder, 0755)
+	if err != nil {
+		log.Error(fmt.Sprintf("Error initializing %s cache", name), err, "elapsedTime", time.Since(start))
+		return nil, err
+	}
+	log.Debug(fmt.Sprintf("%s cache initialized", name), "elapsedTime", time.Since(start))
+
+	return fscache.NewCacheWithHaunter(fs, h)
+}

core/file_caches_test.go

@@ -0,0 +1,100 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/deluan/navidrome/conf"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+// Call NewFileCache and wait for it to be ready
+func callNewFileCache(name, cacheSize, cacheFolder string, maxItems int, getReader ReadFunc) *fileCache {
+	fc := NewFileCache(name, cacheSize, cacheFolder, maxItems, getReader)
+	Eventually(func() bool { return fc.Ready() }).Should(BeTrue())
+	return fc
+}
+
+var _ = Describe("File Caches", func() {
+	BeforeEach(func() {
+		conf.Server.DataFolder, _ = ioutil.TempDir("", "file_caches")
+	})
+	AfterEach(func() {
+		os.RemoveAll(conf.Server.DataFolder)
+	})
+
+	Describe("NewFileCache", func() {
+		It("creates the cache folder", func() {
+			Expect(callNewFileCache("test", "1k", "test", 0, nil)).ToNot(BeNil())
+
+			_, err := os.Stat(filepath.Join(conf.Server.DataFolder, "test"))
+			Expect(os.IsNotExist(err)).To(BeFalse())
+		})
+
+		It("creates the cache folder with invalid size", func() {
+			fc := callNewFileCache("test", "abc", "test", 0, nil)
+			Expect(fc.cache).ToNot(BeNil())
+			Expect(fc.disabled).To(BeFalse())
+		})
+
+		It("returns empty if cache size is '0'", func() {
+			fc := callNewFileCache("test", "0", "test", 0, nil)
+			Expect(fc.cache).To(BeNil())
+			Expect(fc.disabled).To(BeTrue())
+		})
+	})
+
+	Describe("FileCache", func() {
+		It("caches data if cache is enabled", func() {
+			called := false
+			fc := callNewFileCache("test", "1KB", "test", 0, func(ctx context.Context, arg fmt.Stringer) (io.Reader, error) {
+				called = true
+				return strings.NewReader(arg.String()), nil
+			})
+			// First call is a MISS
+			s, err := fc.Get(context.TODO(), &testArg{"test"})
+			Expect(err).To(BeNil())
+			Expect(s.Cached).To(BeFalse())
+			Expect(ioutil.ReadAll(s)).To(Equal([]byte("test")))
+
+			// Second call is a HIT
+			called = false
+			s, err = fc.Get(context.TODO(), &testArg{"test"})
+			Expect(err).To(BeNil())
+			Expect(ioutil.ReadAll(s)).To(Equal([]byte("test")))
+			Expect(s.Cached).To(BeTrue())
+			Expect(called).To(BeFalse())
+		})
+
+		It("does not cache data if cache is disabled", func() {
+			called := false
+			fc := callNewFileCache("test", "0", "test", 0, func(ctx context.Context, arg fmt.Stringer) (io.Reader, error) {
+				called = true
+				return strings.NewReader(arg.String()), nil
+			})
+			// First call is a MISS
+			s, err := fc.Get(context.TODO(), &testArg{"test"})
+			Expect(err).To(BeNil())
+			Expect(s.Cached).To(BeFalse())
+			Expect(ioutil.ReadAll(s)).To(Equal([]byte("test")))
+
+			// Second call is also a MISS
+			called = false
+			s, err = fc.Get(context.TODO(), &testArg{"test"})
+			Expect(err).To(BeNil())
+			Expect(ioutil.ReadAll(s)).To(Equal([]byte("test")))
+			Expect(s.Cached).To(BeFalse())
+			Expect(called).To(BeTrue())
+		})
+	})
+})
+
+type testArg struct{ s string }
+
+func (t *testArg) String() string { return t.s }

core/media_streamer.go

@@ -0,0 +1,186 @@
+package core
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"mime"
+	"os"
+	"time"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/consts"
+	"github.com/deluan/navidrome/core/transcoder"
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
+)
+
+type MediaStreamer interface {
+	NewStream(ctx context.Context, id string, reqFormat string, reqBitRate int) (*Stream, error)
+}
+
+type TranscodingCache FileCache
+
+func NewMediaStreamer(ds model.DataStore, ffm transcoder.Transcoder, cache TranscodingCache) MediaStreamer {
+	return &mediaStreamer{ds: ds, ffm: ffm, cache: cache}
+}
+
+type mediaStreamer struct {
+	ds    model.DataStore
+	ffm   transcoder.Transcoder
+	cache FileCache
+}
+
+type streamJob struct {
+	ms      *mediaStreamer
+	mf      *model.MediaFile
+	format  string
+	bitRate int
+}
+
+func (j *streamJob) String() 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
+
+	log.Debug(ctx, "Streaming TRANSCODED file", "id", mf.ID, "path", mf.Path,
+		"requestBitrate", reqBitRate, "requestFormat", reqFormat,
+		"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix,
+		"selectedBitrate", bitRate, "selectedFormat", format, "cached", cached, "seekable", s.Seekable())
+
+	s.ReadCloser = r
+	if r.Seekable() {
+		s.Seeker = r
+	}
+
+	return s, nil
+}
+
+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
+}
+
+func NewTranscodingCache() TranscodingCache {
+	return NewFileCache("Transcoding", conf.Server.TranscodingCacheSize,
+		consts.TranscodingCacheDir, consts.DefaultTranscodingCacheMaxItems,
+		func(ctx context.Context, arg fmt.Stringer) (io.Reader, error) {
+			job := arg.(*streamJob)
+			t, err := job.ms.ds.Transcoding(ctx).FindByFormat(job.format)
+			if err != nil {
+				log.Error(ctx, "Error loading transcoding command", "format", job.format, err)
+				return nil, os.ErrInvalid
+			}
+			out, err := job.ms.ffm.Start(ctx, t.Command, job.mf.Path, job.bitRate)
+			if err != nil {
+				log.Error(ctx, "Error starting transcoder", "id", job.mf.ID, err)
+				return nil, os.ErrInvalid
+			}
+			return out, nil
+		})
+}

core/media_streamer_test.go

@@ -0,0 +1,214 @@
+package core
+
+import (
+	"context"
+	"io"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/model"
+	"github.com/deluan/navidrome/model/request"
+	"github.com/deluan/navidrome/persistence"
+	. "github.com/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, _ = ioutil.TempDir("", "file_caches")
+		conf.Server.TranscodingCacheSize = "100MB"
+		ds = &persistence.MockDataStore{MockedTranscoding: &mockTranscodingRepository{}}
+		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "suffix": "mp3", "bitRate": 128, "duration": 257.0}]`)
+		testCache := NewTranscodingCache()
+		Eventually(func() bool { return testCache.Ready() }).Should(BeTrue())
+		streamer = NewMediaStreamer(ds, ffmpeg, testCache)
+	})
+
+	AfterEach(func() {
+		os.RemoveAll(conf.Server.DataFolder)
+	})
+
+	Context("NewStream", func() {
+		It("returns a seekable stream if format is 'raw'", func() {
+			s, err := streamer.NewStream(ctx, "123", "raw", 0)
+			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())
+			_, _ = ioutil.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/mock_transcoding_repo_test.go

@@ -0,0 +1,22 @@
+package core
+
+import "github.com/deluan/navidrome/model"
+
+type mockTranscodingRepository struct {
+	model.TranscodingRepository
+}
+
+func (m *mockTranscodingRepository) Get(id string) (*model.Transcoding, error) {
+	return &model.Transcoding{ID: id, TargetFormat: "mp3", DefaultBitRate: 160}, nil
+}
+
+func (m *mockTranscodingRepository) FindByFormat(format string) (*model.Transcoding, error) {
+	switch format {
+	case "mp3":
+		return &model.Transcoding{ID: "mp31", TargetFormat: "mp3", DefaultBitRate: 160}, nil
+	case "oga":
+		return &model.Transcoding{ID: "oga1", TargetFormat: "oga", DefaultBitRate: 128}, nil
+	default:
+		return nil, model.ErrNotFound
+	}
+}

core/transcoder/ffmpeg.go

@@ -0,0 +1,57 @@
+package transcoder
+
+import (
+	"context"
+	"io"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/deluan/navidrome/log"
+)
+
+type Transcoder interface {
+	Start(ctx context.Context, command, path string, maxBitRate int) (f io.ReadCloser, err error)
+}
+
+func New() Transcoder {
+	path, err := exec.LookPath("ffmpeg")
+	if err != nil {
+		log.Error("Unable to find ffmpeg", err)
+	}
+	log.Debug("Found ffmpeg", "path", path)
+	return &ffmpeg{}
+}
+
+type ffmpeg struct{}
+
+func (ff *ffmpeg) Start(ctx context.Context, command, path string, maxBitRate int) (f io.ReadCloser, err error) {
+	args := createTranscodeCommand(command, path, maxBitRate)
+
+	log.Trace(ctx, "Executing ffmpeg command", "cmd", args)
+	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.Replace(s, "%s", path, -1)
+		s = strings.Replace(s, "%b", strconv.Itoa(maxBitRate), -1)
+		split[i] = s
+	}
+
+	return split
+}

core/transcoder/ffmpeg_test.go

@@ -0,0 +1,24 @@
+package transcoder
+
+import (
+	"testing"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/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,15 @@
+package core
+
+import (
+	"github.com/deluan/navidrome/core/transcoder"
+	"github.com/google/wire"
+)
+
+var Set = wire.NewSet(
+	NewArtwork,
+	NewMediaStreamer,
+	NewTranscodingCache,
+	NewImageCache,
+	NewArchiver,
+	transcoder.New,
+)

db/db.go

@@ -6,36 +6,52 @@ import (
 	"sync"
 
 	"github.com/deluan/navidrome/conf"
-	_ "github.com/deluan/navidrome/db/migrations"
+	_ "github.com/deluan/navidrome/db/migration"
 	"github.com/deluan/navidrome/log"
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/pressly/goose"
 )
 
 var (
-	once   sync.Once
 	Driver = "sqlite3"
 	Path   string
 )
 
-func Init() {
+var (
+	once sync.Once
+	db   *sql.DB
+)
+
+func Db() *sql.DB {
 	once.Do(func() {
+		var err error
 		Path = conf.Server.DbPath
 		if Path == ":memory:" {
-			Path = "file::memory:?cache=shared"
+			Path = "file::memory:?cache=shared&_foreign_keys=on"
 			conf.Server.DbPath = Path
 		}
 		log.Debug("Opening DataBase", "dbPath", Path, "driver", Driver)
+		db, err = sql.Open(Driver, Path)
+		if err != nil {
+			panic(err)
+		}
 	})
+	return db
 }
 
 func EnsureLatestVersion() {
-	Init()
-	db, err := sql.Open(Driver, Path)
-	defer db.Close()
+	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("Failed to open DB", err)
-		os.Exit(1)
+		log.Error("Error disabling foreign_keys", err)
 	}
 
 	err = goose.SetDialect(Driver)

db/migration/20200130083147_create_schema.go

@@ -1,4 +1,4 @@
-package migrations
+package migration
 
 import (
 	"database/sql"

db/migration/20200131183653_standardize_item_type.go

@@ -1,4 +1,4 @@
-package migrations
+package migration
 
 import (
 	"database/sql"
@@ -37,7 +37,7 @@ update annotation set item_type = 'media_file' where item_type = 'mediaFile';
 }
 
 func Down20200131183653(tx *sql.Tx) error {
-	tx.Exec(`
+	_, err := tx.Exec(`
 create table search_dg_tmp
 (
 	id varchar(255) not null
@@ -59,5 +59,5 @@ create index search_table
 
 update annotation set item_type = 'mediaFile' where item_type = 'media_file';
 `)
-	return nil
+	return err
 }

db/migration/20200208222418_add_defaults_to_annotations.go

@@ -0,0 +1,55 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200208222418, Down20200208222418)
+}
+
+func Up20200208222418(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+update annotation set play_count = 0 where play_count is null;
+update annotation set rating = 0 where rating is null;
+create table annotation_dg_tmp
+(
+	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 default 0,
+	play_date datetime,
+	rating integer default 0,
+	starred bool default FALSE not null,
+	starred_at datetime,
+	unique (user_id, item_id, item_type)
+);
+
+insert into annotation_dg_tmp(ann_id, user_id, item_id, item_type, play_count, play_date, rating, starred, starred_at) select ann_id, user_id, item_id, item_type, play_count, play_date, rating, starred, starred_at from annotation;
+
+drop table annotation;
+
+alter table annotation_dg_tmp rename to annotation;
+
+create index annotation_play_count
+	on annotation (play_count);
+
+create index annotation_play_date
+	on annotation (play_date);
+
+create index annotation_rating
+	on annotation (rating);
+
+create index annotation_starred
+	on annotation (starred);
+`)
+	return err
+}
+
+func Down20200208222418(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200220143731_change_duration_to_float.go

@@ -0,0 +1,129 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200220143731, Down20200220143731)
+}
+
+func Up20200220143731(tx *sql.Tx) error {
+	notice(tx, "This migration will force the next scan to be a full rescan!")
+	_, err := tx.Exec(`
+create table media_file_dg_tmp
+(
+	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 real 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
+);
+
+insert into media_file_dg_tmp(id, path, title, album, artist, artist_id, album_artist, album_id, has_cover_art, track_number, disc_number, year, size, suffix, duration, bit_rate, genre, compilation, created_at, updated_at) select id, path, title, album, artist, artist_id, album_artist, album_id, has_cover_art, track_number, disc_number, year, size, suffix, duration, bit_rate, genre, compilation, created_at, updated_at from media_file;
+
+drop table media_file;
+
+alter table media_file_dg_tmp rename to media_file;
+
+create index media_file_album_id
+	on media_file (album_id);
+
+create index media_file_genre
+	on media_file (genre);
+
+create index media_file_path
+	on media_file (path);
+
+create index media_file_title
+	on media_file (title);
+
+create table album_dg_tmp
+(
+	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 real default 0 not null,
+	genre varchar(255) default '' not null,
+	created_at datetime,
+	updated_at datetime
+);
+
+insert into album_dg_tmp(id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at) select id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at from album;
+
+drop table album;
+
+alter table album_dg_tmp rename to album;
+
+create index album_artist
+	on album (artist);
+
+create index album_artist_id
+	on album (artist_id);
+
+create index album_genre
+	on album (genre);
+
+create index album_name
+	on album (name);
+
+create index album_year
+	on album (year);
+
+create table playlist_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	comment varchar(255) default '' not null,
+	duration real default 0 not null,
+	owner varchar(255) default '' not null,
+	public bool default FALSE not null,
+	tracks text not null
+);
+
+insert into playlist_dg_tmp(id, name, comment, duration, owner, public, tracks) select id, name, comment, duration, owner, public, tracks from playlist;
+
+drop table playlist;
+
+alter table playlist_dg_tmp rename to playlist;
+
+create index playlist_name
+	on playlist (name);
+
+-- Force a full rescan
+delete from property where id like 'LastScan%';
+update media_file set updated_at = '0001-01-01';
+`)
+	return err
+}
+
+func Down20200220143731(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200310171621_enable_search_by_albumartist.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200310171621, Down20200310171621)
+}
+
+func Up20200310171621(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed to enable search by Album Artist!")
+	return forceFullRescan(tx)
+}
+
+func Down20200310171621(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200310181627_add_transcoding_and_player_tables.go

@@ -0,0 +1,53 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200310181627, Down20200310181627)
+}
+
+func Up20200310181627(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table transcoding
+(
+	id varchar(255) not null primary key,
+	name varchar(255) not null,
+	target_format varchar(255) not null,
+	command varchar(255) default '' not null,
+	default_bit_rate int default 192,
+	unique (name),
+	unique (target_format)
+);
+
+create table player 
+(
+	id varchar(255) not null primary key,
+    name varchar not null,
+    type varchar,
+    user_name varchar not null, 
+    client varchar not null, 
+    ip_address varchar,
+    last_seen timestamp,
+    max_bit_rate int default 0,
+    transcoding_id varchar,
+	unique (name),
+	foreign key (transcoding_id)
+	   references transcoding(id)
+		  on update restrict 
+		  on delete restrict
+);
+`)
+	return err
+}
+
+func Down20200310181627(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+drop table transcoding;
+drop table player;
+`)
+	return err
+}

db/migration/20200319211049_merge_search_into_main_tables.go

@@ -0,0 +1,41 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200319211049, Down20200319211049)
+}
+
+func Up20200319211049(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table media_file
+	add full_text varchar(255) default '';
+create index if not exists media_file_full_text
+	on media_file (full_text);
+
+alter table album
+	add full_text varchar(255) default '';
+create index if not exists album_full_text
+	on album (full_text);
+
+alter table artist
+	add full_text varchar(255) default '';
+create index if not exists artist_full_text
+	on artist (full_text);
+
+drop table if exists search;
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed!")
+	return forceFullRescan(tx)
+}
+
+func Down20200319211049(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200325185135_add_album_artist_id.go

@@ -0,0 +1,34 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200325185135, Down20200325185135)
+}
+
+func Up20200325185135(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table album
+	add album_artist_id varchar(255) default '';
+create index album_artist_album_id
+	on album (album_artist_id);
+
+alter table media_file
+	add album_artist_id varchar(255) default '';
+create index media_file_artist_album_id
+	on media_file (album_artist_id);
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed!")
+	return forceFullRescan(tx)
+}
+
+func Down20200325185135(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200326090707_fix_album_artists_importing.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200326090707, Down20200326090707)
+}
+
+func Up20200326090707(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed!")
+	return forceFullRescan(tx)
+}
+
+func Down20200326090707(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200327193744_add_year_range_to_album.go

@@ -0,0 +1,80 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200327193744, Down20200327193744)
+}
+
+func Up20200327193744(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table album_dg_tmp
+(
+	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,
+    min_year int default 0 not null,
+	max_year integer default 0 not null,
+	compilation bool default FALSE not null,
+	song_count integer default 0 not null,
+	duration real default 0 not null,
+	genre varchar(255) default '' not null,
+	created_at datetime,
+	updated_at datetime,
+	full_text varchar(255) default '',
+	album_artist_id varchar(255) default ''
+);
+
+insert into album_dg_tmp(id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, max_year, compilation, song_count, duration, genre, created_at, updated_at, full_text, album_artist_id) select id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at, full_text, album_artist_id from album;
+
+drop table album;
+
+alter table album_dg_tmp rename to album;
+
+create index album_artist
+	on album (artist);
+
+create index album_artist_album
+	on album (artist);
+
+create index album_artist_album_id
+	on album (album_artist_id);
+
+create index album_artist_id
+	on album (artist_id);
+
+create index album_full_text
+	on album (full_text);
+
+create index album_genre
+	on album (genre);
+
+create index album_name
+	on album (name);
+
+create index album_min_year
+	on album (min_year);
+
+create index album_max_year
+	on album (max_year);
+
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed!")
+	return forceFullRescan(tx)
+}
+
+func Down20200327193744(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200404214704_add_indexes.go

@@ -0,0 +1,29 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200404214704, Down20200404214704)
+}
+
+func Up20200404214704(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create index if not exists media_file_year
+	on media_file (year);
+
+create index if not exists media_file_duration
+	on media_file (duration);
+
+create index if not exists media_file_track_number
+	on media_file (disc_number, track_number);
+`)
+	return err
+}
+
+func Down20200404214704(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200409002249_enable_search_by_tracks_artists.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200409002249, Down20200409002249)
+}
+
+func Up20200409002249(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed to enable search by individual Artist in an Album!")
+	return forceFullRescan(tx)
+}
+
+func Down20200409002249(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200411164603_add_created_and_updated_fields_to_playlists.go

@@ -0,0 +1,27 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200411164603, Down20200411164603)
+}
+
+func Up20200411164603(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table playlist
+	add created_at datetime;
+alter table playlist
+	add updated_at datetime;
+update playlist 
+	set created_at = datetime('now'), updated_at = datetime('now');
+`)
+	return err
+}
+
+func Down20200411164603(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200418110522_reindex_to_fix_album_years.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200418110522, Down20200418110522)
+}
+
+func Up20200418110522(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed to fix search Albums by year")
+	return forceFullRescan(tx)
+}
+
+func Down20200418110522(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200419222708_reindex_to_change_full_text_search.go

@@ -0,0 +1,20 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200419222708, Down20200419222708)
+}
+
+func Up20200419222708(tx *sql.Tx) error {
+	notice(tx, "A full rescan will be performed to change the search behaviour")
+	return forceFullRescan(tx)
+}
+
+func Down20200419222708(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200423204116_add_sort_fields.go

@@ -0,0 +1,65 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200423204116, Down20200423204116)
+}
+
+func Up20200423204116(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table artist
+	add order_artist_name varchar(255) collate nocase;
+alter table artist
+	add sort_artist_name varchar(255) collate nocase;
+create index if not exists artist_order_artist_name
+	on artist (order_artist_name);
+
+alter table album
+	add order_album_name varchar(255) collate nocase;
+alter table album
+	add order_album_artist_name varchar(255) collate nocase;
+alter table album
+	add sort_album_name varchar(255) collate nocase;
+alter table album
+	add sort_artist_name varchar(255) collate nocase;
+alter table album
+	add sort_album_artist_name varchar(255) collate nocase;
+create index if not exists album_order_album_name
+	on album (order_album_name);
+create index if not exists album_order_album_artist_name
+	on album (order_album_artist_name);
+
+alter table media_file
+	add order_album_name varchar(255) collate nocase;
+alter table media_file
+	add order_album_artist_name varchar(255) collate nocase;
+alter table media_file
+	add order_artist_name varchar(255) collate nocase;
+alter table media_file
+	add sort_album_name varchar(255) collate nocase;
+alter table media_file
+	add sort_artist_name varchar(255) collate nocase;
+alter table media_file
+	add sort_album_artist_name varchar(255) collate nocase;
+alter table media_file
+	add sort_title varchar(255) collate nocase;
+create index if not exists media_file_order_album_name
+	on media_file (order_album_name);
+create index if not exists media_file_order_artist_name
+	on media_file (order_artist_name);
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed to change the search behaviour")
+	return forceFullRescan(tx)
+}
+
+func Down20200423204116(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200508093059_add_artist_song_count.go

@@ -0,0 +1,27 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200508093059, Down20200508093059)
+}
+
+func Up20200508093059(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table artist
+	add song_count integer default 0 not null;
+`)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed to calculate artists' song counts")
+	return forceFullRescan(tx)
+}
+
+func Down20200508093059(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200512104202_add_disc_subtitle.go

@@ -0,0 +1,27 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200512104202, Down20200512104202)
+}
+
+func Up20200512104202(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table media_file 
+    add disc_subtitle varchar(255);
+    `)
+	if err != nil {
+		return err
+	}
+	notice(tx, "A full rescan will be performed to import disc subtitles")
+	return forceFullRescan(tx)
+}
+
+func Down20200512104202(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200516140647_add_playlist_tracks_table.go

@@ -0,0 +1,100 @@
+package migration
+
+import (
+	"database/sql"
+	"strings"
+
+	"github.com/deluan/navidrome/log"
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200516140647, Down20200516140647)
+}
+
+func Up20200516140647(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table if not exists playlist_tracks
+(
+	id integer default 0 not null, 
+    playlist_id varchar(255) not null, 
+	media_file_id varchar(255) not null
+);
+
+create unique index if not exists playlist_tracks_pos
+	on playlist_tracks (playlist_id, id);
+`)
+	if err != nil {
+		return err
+	}
+	rows, err := tx.Query("select id, tracks from playlist")
+	if err != nil {
+		return err
+	}
+	defer rows.Close()
+	var id, tracks string
+	for rows.Next() {
+		err := rows.Scan(&id, &tracks)
+		if err != nil {
+			return err
+		}
+		err = Up20200516140647UpdatePlaylistTracks(tx, id, tracks)
+		if err != nil {
+			return err
+		}
+	}
+	err = rows.Err()
+	if err != nil {
+		return err
+	}
+
+	_, err = tx.Exec(`
+create table playlist_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	comment varchar(255) default '' not null,
+	duration real default 0 not null,
+	song_count integer default 0 not null,
+	owner varchar(255) default '' not null,
+	public bool default FALSE not null,
+	created_at datetime,
+	updated_at datetime
+);
+
+insert into playlist_dg_tmp(id, name, comment, duration, owner, public, created_at, updated_at) 
+	select id, name, comment, duration, owner, public, created_at, updated_at from playlist;
+
+drop table playlist;
+
+alter table playlist_dg_tmp rename to playlist;
+
+create index playlist_name
+	on playlist (name);
+
+update playlist set song_count = (select count(*) from playlist_tracks where playlist_id = playlist.id)
+where id <> ''
+
+`)
+	return err
+}
+
+func Up20200516140647UpdatePlaylistTracks(tx *sql.Tx, id string, tracks string) error {
+	trackList := strings.Split(tracks, ",")
+	stmt, err := tx.Prepare("insert into playlist_tracks (playlist_id, media_file_id, id) values (?, ?, ?)")
+	if err != nil {
+		return err
+	}
+	for i, trackId := range trackList {
+		_, err := stmt.Exec(id, trackId, i+1)
+		if err != nil {
+			log.Error("Error adding track to playlist", "playlistId", id, "trackId", trackId, err)
+		}
+	}
+	return nil
+}
+
+func Down20200516140647(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200608153717_referential_integrity.go

@@ -0,0 +1,137 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200608153717, Down20200608153717)
+}
+
+func Up20200608153717(tx *sql.Tx) error {
+	// First delete dangling players
+	_, err := tx.Exec(`
+delete from player where user_name not in (select user_name from user)`)
+	if err != nil {
+		return err
+	}
+
+	// Also delete dangling players
+	_, err = tx.Exec(`
+delete from playlist where owner not in (select user_name from user)`)
+	if err != nil {
+		return err
+	}
+
+	// Also delete dangling playlist tracks
+	_, err = tx.Exec(`
+delete from playlist_tracks where playlist_id not in (select id from playlist)`)
+	if err != nil {
+		return err
+	}
+
+	// Add foreign key to player table
+	err = updatePlayer_20200608153717(tx)
+	if err != nil {
+		return err
+	}
+
+	// Add foreign key to playlist table
+	err = updatePlaylist_20200608153717(tx)
+	if err != nil {
+		return err
+	}
+
+	// Add foreign keys to playlist_tracks table
+	return updatePlaylistTracks_20200608153717(tx)
+}
+
+func updatePlayer_20200608153717(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table player_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	name varchar not null
+		unique,
+	type varchar,
+	user_name varchar not null
+		references user (user_name)
+			on update cascade on delete cascade,
+	client varchar not null,
+	ip_address varchar,
+	last_seen timestamp,
+	max_bit_rate int default 0,
+	transcoding_id varchar null
+);
+
+insert into player_dg_tmp(id, name, type, user_name, client, ip_address, last_seen, max_bit_rate, transcoding_id) select id, name, type, user_name, client, ip_address, last_seen, max_bit_rate, transcoding_id from player;
+
+drop table player;
+
+alter table player_dg_tmp rename to player;
+`)
+	return err
+}
+
+func updatePlaylist_20200608153717(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table playlist_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	comment varchar(255) default '' not null,
+	duration real default 0 not null,
+	song_count integer default 0 not null,
+	owner varchar(255) default '' not null
+		constraint playlist_user_user_name_fk
+			references user (user_name)
+				on update cascade on delete cascade,
+	public bool default FALSE not null,
+	created_at datetime,
+	updated_at datetime
+);
+
+insert into playlist_dg_tmp(id, name, comment, duration, song_count, owner, public, created_at, updated_at) select id, name, comment, duration, song_count, owner, public, created_at, updated_at from playlist;
+
+drop table playlist;
+
+alter table playlist_dg_tmp rename to playlist;
+
+create index playlist_name
+	on playlist (name);
+`)
+	return err
+}
+
+func updatePlaylistTracks_20200608153717(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table playlist_tracks_dg_tmp
+(
+	id integer default 0 not null,
+	playlist_id varchar(255) not null
+		constraint playlist_tracks_playlist_id_fk
+			references playlist
+				on update cascade on delete cascade,
+	media_file_id varchar(255) not null
+);
+
+insert into playlist_tracks_dg_tmp(id, playlist_id, media_file_id) select id, playlist_id, media_file_id from playlist_tracks;
+
+drop table playlist_tracks;
+
+alter table playlist_tracks_dg_tmp rename to playlist_tracks;
+
+create unique index playlist_tracks_pos
+	on playlist_tracks (playlist_id, id);
+
+`)
+	return err
+}
+
+func Down20200608153717(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200706231659_add_default_transcodings.go

@@ -0,0 +1,43 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/deluan/navidrome/consts"
+	"github.com/google/uuid"
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(upAddDefaultTranscodings, downAddDefaultTranscodings)
+}
+
+func upAddDefaultTranscodings(tx *sql.Tx) error {
+	row := tx.QueryRow("SELECT COUNT(*) FROM transcoding")
+	var count int
+	err := row.Scan(&count)
+	if err != nil {
+		return err
+	}
+	if count > 0 {
+		return nil
+	}
+
+	stmt, err := tx.Prepare("insert into transcoding (id, name, target_format, default_bit_rate, command) values (?, ?, ?, ?, ?)")
+	if err != nil {
+		return err
+	}
+
+	for _, t := range consts.DefaultTranscodings {
+		r, _ := uuid.NewRandom()
+		_, err := stmt.Exec(r.String(), t["name"], t["targetFormat"], t["defaultBitRate"], t["command"])
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func downAddDefaultTranscodings(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200710211442_add_playlist_path.go

@@ -0,0 +1,27 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(upAddPlaylistPath, downAddPlaylistPath)
+}
+
+func upAddPlaylistPath(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+alter table playlist
+	add path string default '' not null;
+
+alter table playlist
+	add sync bool default false not null;
+`)
+
+	return err
+}
+
+func downAddPlaylistPath(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200731095603_create_play_queues_table.go

@@ -0,0 +1,36 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(upCreatePlayQueuesTable, downCreatePlayQueuesTable)
+}
+
+func upCreatePlayQueuesTable(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table playqueue
+(
+    id         varchar(255) not null primary key,
+    user_id    varchar(255) not null
+            references user (id)
+            on update cascade on delete cascade,
+	comment    varchar(255),
+    current    varchar(255) not null,
+    position   integer,
+    changed_by varchar(255),
+    items      varchar(255),
+    created_at datetime,
+    updated_at datetime
+);
+`)
+
+	return err
+}
+
+func downCreatePlayQueuesTable(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200801101355_create_bookmark_table.go

@@ -0,0 +1,53 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(upCreateBookmarkTable, downCreateBookmarkTable)
+}
+
+func upCreateBookmarkTable(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table bookmark
+(
+    user_id    varchar(255) not null
+        references user
+            on update cascade on delete cascade,
+    item_id    varchar(255) not null,
+    item_type  varchar(255) not null,
+    comment    varchar(255),
+    position   integer,
+    changed_by varchar(255),
+    created_at datetime,
+    updated_at datetime,
+    constraint bookmark_pk
+        unique (user_id, item_id, item_type)
+);
+
+create table playqueue_dg_tmp
+(
+	id varchar(255) not null,
+	user_id varchar(255) not null
+		references user
+			on update cascade on delete cascade,
+	current varchar(255),
+	position real,
+	changed_by varchar(255),
+	items varchar(255),
+	created_at datetime,
+	updated_at datetime
+);
+drop table playqueue;
+alter table playqueue_dg_tmp rename to playqueue;
+`)
+
+	return err
+}
+
+func downCreateBookmarkTable(tx *sql.Tx) error {
+	return nil
+}

db/migration/20200819111809_drop_email_unique_constraint.go

@@ -0,0 +1,42 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(upDropEmailUniqueConstraint, downDropEmailUniqueConstraint)
+}
+
+func upDropEmailUniqueConstraint(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create table user_dg_tmp
+(
+	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,
+	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
+);
+
+insert into user_dg_tmp(id, user_name, name, email, password, is_admin, last_login_at, last_access_at, created_at, updated_at) select id, user_name, name, email, password, is_admin, last_login_at, last_access_at, created_at, updated_at from user;
+
+drop table user;
+
+alter table user_dg_tmp rename to user;
+`)
+	return err
+}
+
+func downDropEmailUniqueConstraint(tx *sql.Tx) error {
+	return nil
+}

db/migration/20201003111749_add_starred_at_index.go

@@ -0,0 +1,23 @@
+package migration
+
+import (
+	"database/sql"
+
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20201003111749, Down20201003111749)
+}
+
+func Up20201003111749(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+create index if not exists annotation_starred_at
+	on annotation (starred_at);
+    `)
+	return err
+}
+
+func Down20201003111749(tx *sql.Tx) error {
+	return nil
+}

db/migration/migration.go

@@ -0,0 +1,55 @@
+package migration
+
+import (
+	"database/sql"
+	"fmt"
+	"sync"
+
+	"github.com/deluan/navidrome/consts"
+)
+
+// Use this in migrations that need to communicate something important (braking changes, forced reindexes, etc...)
+func notice(tx *sql.Tx, msg string) {
+	if isDBInitialized(tx) {
+		fmt.Printf(`
+*************************************************************************************
+NOTICE: %s
+*************************************************************************************
+
+`, msg)
+	}
+}
+
+// Call this in migrations that requires a full rescan
+func forceFullRescan(tx *sql.Tx) error {
+	_, err := tx.Exec(`
+delete from property where id like 'LastScan%';
+update media_file set updated_at = '0001-01-01';
+`)
+	return err
+}
+
+var once sync.Once
+
+func isDBInitialized(tx *sql.Tx) (initialized bool) {
+	once.Do(func() {
+		rows, err := tx.Query("select count(*) from property where id='" + consts.InitialSetupFlagKey + "'")
+		checkErr(err)
+		initialized = checkCount(rows) > 0
+	})
+	return initialized
+}
+
+func checkCount(rows *sql.Rows) (count int) {
+	for rows.Next() {
+		err := rows.Scan(&count)
+		checkErr(err)
+	}
+	return count
+}
+
+func checkErr(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

docker-compose.yml

@@ -1,18 +0,0 @@
-# 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"
-      - "./music:/music"

engine/browser.go

@@ -1,218 +0,0 @@
-package engine
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/utils"
-)
-
-type Browser interface {
-	MediaFolders(ctx context.Context) (model.MediaFolders, error)
-	Indexes(ctx context.Context, mediaFolderId string, ifModifiedSince time.Time) (model.ArtistIndexes, time.Time, error)
-	Directory(ctx context.Context, id string) (*DirectoryInfo, error)
-	Artist(ctx context.Context, id string) (*DirectoryInfo, error)
-	Album(ctx context.Context, id string) (*DirectoryInfo, error)
-	GetSong(ctx context.Context, id string) (*Entry, error)
-	GetGenres(ctx context.Context) (model.Genres, error)
-}
-
-func NewBrowser(ds model.DataStore) Browser {
-	return &browser{ds}
-}
-
-type browser struct {
-	ds model.DataStore
-}
-
-func (b *browser) MediaFolders(ctx context.Context) (model.MediaFolders, error) {
-	return b.ds.MediaFolder(ctx).GetAll()
-}
-
-func (b *browser) Indexes(ctx context.Context, mediaFolderId string, ifModifiedSince time.Time) (model.ArtistIndexes, time.Time, error) {
-	// TODO Proper handling of mediaFolderId param
-	folder, err := b.ds.MediaFolder(ctx).Get(mediaFolderId)
-
-	l, err := b.ds.Property(ctx).DefaultGet(model.PropLastScan+"-"+folder.Path, "-1")
-	ms, _ := strconv.ParseInt(l, 10, 64)
-	lastModified := utils.ToTime(ms)
-
-	if err != nil {
-		return nil, time.Time{}, fmt.Errorf("error retrieving LastScan property: %v", err)
-	}
-
-	if lastModified.After(ifModifiedSince) {
-		indexes, err := b.ds.Artist(ctx).GetIndex()
-		return indexes, lastModified, err
-	}
-
-	return nil, lastModified, nil
-}
-
-type DirectoryInfo struct {
-	Id         string
-	Name       string
-	Entries    Entries
-	Parent     string
-	Starred    time.Time
-	PlayCount  int32
-	UserRating int
-	AlbumCount int
-	CoverArt   string
-	Artist     string
-	ArtistId   string
-	SongCount  int
-	Duration   int
-	Created    time.Time
-	Year       int
-	Genre      string
-}
-
-func (b *browser) Artist(ctx context.Context, id string) (*DirectoryInfo, error) {
-	a, albums, err := b.retrieveArtist(ctx, id)
-	if err != nil {
-		return nil, err
-	}
-	log.Debug(ctx, "Found Artist", "id", id, "name", a.Name)
-	var albumIds []string
-	for _, al := range albums {
-		albumIds = append(albumIds, al.ID)
-	}
-	return b.buildArtistDir(a, albums), nil
-}
-
-func (b *browser) Album(ctx context.Context, id string) (*DirectoryInfo, error) {
-	al, tracks, err := b.retrieveAlbum(ctx, id)
-	if err != nil {
-		return nil, err
-	}
-	log.Debug(ctx, "Found Album", "id", id, "name", al.Name)
-	var mfIds []string
-	for _, mf := range tracks {
-		mfIds = append(mfIds, mf.ID)
-	}
-
-	return b.buildAlbumDir(al, tracks), nil
-}
-
-func (b *browser) Directory(ctx context.Context, id string) (*DirectoryInfo, error) {
-	switch {
-	case b.isArtist(ctx, id):
-		return b.Artist(ctx, id)
-	case b.isAlbum(ctx, id):
-		return b.Album(ctx, id)
-	default:
-		log.Debug(ctx, "Directory not found", "id", id)
-		return nil, model.ErrNotFound
-	}
-}
-
-func (b *browser) GetSong(ctx context.Context, id string) (*Entry, error) {
-	mf, err := b.ds.MediaFile(ctx).Get(id)
-	if err != nil {
-		return nil, err
-	}
-
-	entry := FromMediaFile(mf)
-	return &entry, nil
-}
-
-func (b *browser) GetGenres(ctx context.Context) (model.Genres, error) {
-	genres, err := b.ds.Genre(ctx).GetAll()
-	for i, g := range genres {
-		if strings.TrimSpace(g.Name) == "" {
-			genres[i].Name = "<Empty>"
-		}
-	}
-	sort.Slice(genres, func(i, j int) bool {
-		return genres[i].Name < genres[j].Name
-	})
-	return genres, err
-}
-
-func (b *browser) buildArtistDir(a *model.Artist, albums model.Albums) *DirectoryInfo {
-	dir := &DirectoryInfo{
-		Id:         a.ID,
-		Name:       a.Name,
-		AlbumCount: a.AlbumCount,
-	}
-
-	dir.Entries = make(Entries, len(albums))
-	for i, al := range albums {
-		dir.Entries[i] = FromAlbum(&al)
-		dir.PlayCount += int32(al.PlayCount)
-	}
-	return dir
-}
-
-func (b *browser) buildAlbumDir(al *model.Album, tracks model.MediaFiles) *DirectoryInfo {
-	dir := &DirectoryInfo{
-		Id:         al.ID,
-		Name:       al.Name,
-		Parent:     al.ArtistID,
-		Artist:     al.Artist,
-		ArtistId:   al.ArtistID,
-		SongCount:  al.SongCount,
-		Duration:   al.Duration,
-		Created:    al.CreatedAt,
-		Year:       al.Year,
-		Genre:      al.Genre,
-		CoverArt:   al.CoverArtId,
-		PlayCount:  int32(al.PlayCount),
-		Starred:    al.StarredAt,
-		UserRating: al.Rating,
-	}
-
-	dir.Entries = FromMediaFiles(tracks)
-	return dir
-}
-
-func (b *browser) isArtist(ctx context.Context, id string) bool {
-	found, err := b.ds.Artist(ctx).Exists(id)
-	if err != nil {
-		log.Debug(ctx, "Error searching for Artist", "id", id, err)
-		return false
-	}
-	return found
-}
-
-func (b *browser) isAlbum(ctx context.Context, id string) bool {
-	found, err := b.ds.Album(ctx).Exists(id)
-	if err != nil {
-		log.Debug(ctx, "Error searching for Album", "id", id, err)
-		return false
-	}
-	return found
-}
-
-func (b *browser) retrieveArtist(ctx context.Context, id string) (a *model.Artist, as model.Albums, err error) {
-	a, err = b.ds.Artist(ctx).Get(id)
-	if err != nil {
-		err = fmt.Errorf("Error reading Artist %s from DB: %v", id, err)
-		return
-	}
-
-	if as, err = b.ds.Album(ctx).FindByArtist(id); err != nil {
-		err = fmt.Errorf("Error reading %s's albums from DB: %v", a.Name, err)
-	}
-	return
-}
-
-func (b *browser) retrieveAlbum(ctx context.Context, id string) (al *model.Album, mfs model.MediaFiles, err error) {
-	al, err = b.ds.Album(ctx).Get(id)
-	if err != nil {
-		err = fmt.Errorf("Error reading Album %s from DB: %v", id, err)
-		return
-	}
-
-	if mfs, err = b.ds.MediaFile(ctx).FindByAlbum(id); err != nil {
-		err = fmt.Errorf("Error reading %s's tracks from DB: %v", al.Name, err)
-	}
-	return
-}

engine/browser_test.go

@@ -1,52 +0,0 @@
-package engine
-
-import (
-	"context"
-	"errors"
-
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/persistence"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Browser", func() {
-	var repo *mockGenreRepository
-	var b Browser
-
-	BeforeSuite(func() {
-		repo = &mockGenreRepository{data: model.Genres{
-			{Name: "Rock", SongCount: 1000, AlbumCount: 100},
-			{Name: "", SongCount: 13, AlbumCount: 13},
-			{Name: "Electronic", SongCount: 4000, AlbumCount: 40},
-		}}
-		var ds = &persistence.MockDataStore{MockedGenre: repo}
-		b = &browser{ds: ds}
-	})
-
-	It("returns sorted data", func() {
-		Expect(b.GetGenres(context.TODO())).To(Equal(model.Genres{
-			{Name: "<Empty>", SongCount: 13, AlbumCount: 13},
-			{Name: "Electronic", SongCount: 4000, AlbumCount: 40},
-			{Name: "Rock", SongCount: 1000, AlbumCount: 100},
-		}))
-	})
-
-	It("bubbles up errors", func() {
-		repo.err = errors.New("generic error")
-		_, err := b.GetGenres(context.TODO())
-		Expect(err).ToNot(BeNil())
-	})
-})
-
-type mockGenreRepository struct {
-	data model.Genres
-	err  error
-}
-
-func (r *mockGenreRepository) GetAll() (model.Genres, error) {
-	if r.err != nil {
-		return nil, r.err
-	}
-	return r.data, nil
-}

engine/cover.go

@@ -1,112 +0,0 @@
-package engine
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"image"
-	_ "image/gif"
-	"image/jpeg"
-	_ "image/png"
-	"io"
-	"net/http"
-	"os"
-	"strings"
-
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/static"
-	"github.com/dhowden/tag"
-	"github.com/nfnt/resize"
-)
-
-type Cover interface {
-	Get(ctx context.Context, id string, size int, out io.Writer) error
-}
-
-type cover struct {
-	ds model.DataStore
-}
-
-func NewCover(ds model.DataStore) Cover {
-	return &cover{ds}
-}
-
-func (c *cover) getCoverPath(ctx context.Context, id string) (string, error) {
-	switch {
-	case strings.HasPrefix(id, "al-"):
-		id = id[3:]
-		al, err := c.ds.Album(ctx).Get(id)
-		if err != nil {
-			return "", err
-		}
-		return al.CoverArtPath, nil
-	default:
-		mf, err := c.ds.MediaFile(ctx).Get(id)
-		if err != nil {
-			return "", err
-		}
-		if mf.HasCoverArt {
-			return mf.Path, nil
-		}
-	}
-	return "", model.ErrNotFound
-}
-
-func (c *cover) Get(ctx context.Context, id string, size int, out io.Writer) error {
-	path, err := c.getCoverPath(ctx, id)
-	if err != nil && err != model.ErrNotFound {
-		return err
-	}
-
-	var reader io.Reader
-
-	if err != model.ErrNotFound {
-		reader, err = readFromTag(path)
-	} else {
-		var f http.File
-		f, err = static.AssetFile().Open("default_cover.jpg")
-		if err == nil {
-			defer f.Close()
-			reader = f
-		}
-	}
-
-	if err != nil {
-		return model.ErrNotFound
-	}
-
-	if size > 0 {
-		return resizeImage(reader, size, out)
-	}
-	_, err = io.Copy(out, reader)
-	return err
-}
-
-func resizeImage(reader io.Reader, size int, out io.Writer) error {
-	img, _, err := image.Decode(reader)
-	if err != nil {
-		return err
-	}
-
-	m := resize.Resize(uint(size), 0, img, resize.NearestNeighbor)
-	return jpeg.Encode(out, m, &jpeg.Options{Quality: 75})
-}
-
-func readFromTag(path string) (io.Reader, 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("error extracting art from file " + path)
-	}
-	return bytes.NewReader(picture.Data), nil
-}

engine/list_generator.go

@@ -1,165 +0,0 @@
-package engine
-
-import (
-	"context"
-	"time"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/deluan/navidrome/model"
-)
-
-type ListGenerator interface {
-	GetNewest(ctx context.Context, offset int, size int) (Entries, error)
-	GetRecent(ctx context.Context, offset int, size int) (Entries, error)
-	GetFrequent(ctx context.Context, offset int, size int) (Entries, error)
-	GetHighest(ctx context.Context, offset int, size int) (Entries, error)
-	GetRandom(ctx context.Context, offset int, size int) (Entries, error)
-	GetByName(ctx context.Context, offset int, size int) (Entries, error)
-	GetByArtist(ctx context.Context, offset int, size int) (Entries, error)
-	GetStarred(ctx context.Context, offset int, size int) (Entries, error)
-	GetAllStarred(ctx context.Context) (artists Entries, albums Entries, mediaFiles Entries, err error)
-	GetNowPlaying(ctx context.Context) (Entries, error)
-	GetRandomSongs(ctx context.Context, size int, genre string) (Entries, error)
-}
-
-func NewListGenerator(ds model.DataStore, npRepo NowPlayingRepository) ListGenerator {
-	return &listGenerator{ds, npRepo}
-}
-
-type listGenerator struct {
-	ds     model.DataStore
-	npRepo NowPlayingRepository
-}
-
-func (g *listGenerator) query(ctx context.Context, qo model.QueryOptions) (Entries, error) {
-	albums, err := g.ds.Album(ctx).GetAll(qo)
-	if err != nil {
-		return nil, err
-	}
-	albumIds := make([]string, len(albums))
-	for i, al := range albums {
-		albumIds[i] = al.ID
-	}
-	return FromAlbums(albums), err
-}
-
-func (g *listGenerator) GetNewest(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "CreatedAt", Order: "desc", Offset: offset, Max: size}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetRecent(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "PlayDate", Order: "desc", Offset: offset, Max: size,
-		Filters: squirrel.Gt{"play_date": time.Time{}}}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetFrequent(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "PlayCount", Order: "desc", Offset: offset, Max: size,
-		Filters: squirrel.Gt{"play_count": 0}}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetHighest(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "Rating", Order: "desc", Offset: offset, Max: size,
-		Filters: squirrel.Gt{"rating": 0}}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetByName(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "Name", Offset: offset, Max: size}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetByArtist(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Sort: "Artist", Offset: offset, Max: size}
-	return g.query(ctx, qo)
-}
-
-func (g *listGenerator) GetRandom(ctx context.Context, offset int, size int) (Entries, error) {
-	albums, err := g.ds.Album(ctx).GetRandom(model.QueryOptions{Max: size, Offset: offset})
-	if err != nil {
-		return nil, err
-	}
-
-	return FromAlbums(albums), nil
-}
-
-func (g *listGenerator) GetRandomSongs(ctx context.Context, size int, genre string) (Entries, error) {
-	options := model.QueryOptions{Max: size}
-	if genre != "" {
-		options.Filters = squirrel.Eq{"genre": genre}
-	}
-	mediaFiles, err := g.ds.MediaFile(ctx).GetRandom(options)
-	if err != nil {
-		return nil, err
-	}
-
-	return FromMediaFiles(mediaFiles), nil
-}
-
-func (g *listGenerator) GetStarred(ctx context.Context, offset int, size int) (Entries, error) {
-	qo := model.QueryOptions{Offset: offset, Max: size, Sort: "starred_at", Order: "desc"}
-	albums, err := g.ds.Album(ctx).GetStarred(qo)
-	if err != nil {
-		return nil, err
-	}
-
-	return FromAlbums(albums), nil
-}
-
-func (g *listGenerator) GetAllStarred(ctx context.Context) (artists Entries, albums Entries, mediaFiles Entries, err error) {
-	options := model.QueryOptions{Sort: "starred_at", Order: "desc"}
-
-	ars, err := g.ds.Artist(ctx).GetStarred(options)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	als, err := g.ds.Album(ctx).GetStarred(options)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	mfs, err := g.ds.MediaFile(ctx).GetStarred(options)
-	if err != nil {
-		return nil, nil, nil, err
-	}
-
-	var mfIds []string
-	for _, mf := range mfs {
-		mfIds = append(mfIds, mf.ID)
-	}
-
-	var artistIds []string
-	for _, ar := range ars {
-		artistIds = append(artistIds, ar.ID)
-	}
-
-	artists = FromArtists(ars)
-	albums = FromAlbums(als)
-	mediaFiles = FromMediaFiles(mfs)
-
-	return
-}
-
-func (g *listGenerator) GetNowPlaying(ctx context.Context) (Entries, error) {
-	npInfo, err := g.npRepo.GetAll()
-	if err != nil {
-		return nil, err
-	}
-	entries := make(Entries, len(npInfo))
-	for i, np := range npInfo {
-		mf, err := g.ds.MediaFile(ctx).Get(np.TrackID)
-		if err != nil {
-			return nil, err
-		}
-		entries[i] = FromMediaFile(mf)
-		entries[i].UserName = np.Username
-		entries[i].MinutesAgo = int(time.Now().Sub(np.Start).Minutes())
-		entries[i].PlayerId = np.PlayerId
-		entries[i].PlayerName = np.PlayerName
-
-	}
-	return entries, nil
-}

engine/media_streamer.go

@@ -1,220 +0,0 @@
-package engine
-
-import (
-	"context"
-	"io"
-	"io/ioutil"
-	"mime"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/utils"
-)
-
-type MediaStreamer interface {
-	NewStream(ctx context.Context, id string, maxBitRate int, format string) (mediaStream, error)
-}
-
-func NewMediaStreamer(ds model.DataStore) MediaStreamer {
-	return &mediaStreamer{ds: ds}
-}
-
-type mediaStream interface {
-	io.ReadSeeker
-	ContentType() string
-	Name() string
-	ModTime() time.Time
-	Close() error
-}
-
-type mediaStreamer struct {
-	ds model.DataStore
-}
-
-func (ms *mediaStreamer) NewStream(ctx context.Context, id string, maxBitRate int, format string) (mediaStream, error) {
-	mf, err := ms.ds.MediaFile(ctx).Get(id)
-	if err != nil {
-		return nil, err
-	}
-
-	var bitRate int
-
-	if format == "raw" || !conf.Server.EnableDownsampling {
-		bitRate = mf.BitRate
-		format = mf.Suffix
-	} else {
-		if maxBitRate == 0 {
-			bitRate = mf.BitRate
-		} else {
-			bitRate = utils.MinInt(mf.BitRate, maxBitRate)
-		}
-		format = mf.Suffix
-	}
-	if conf.Server.MaxBitRate != 0 {
-		bitRate = utils.MinInt(bitRate, conf.Server.MaxBitRate)
-	}
-
-	var stream mediaStream
-
-	if bitRate == mf.BitRate && mime.TypeByExtension("."+format) == mf.ContentType() {
-		log.Debug(ctx, "Streaming raw file", "id", mf.ID, "path", mf.Path,
-			"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
-
-		f, err := os.Open(mf.Path)
-		if err != nil {
-			return nil, err
-		}
-		stream = &rawMediaStream{ctx: ctx, mf: mf, file: f}
-		return stream, nil
-	}
-
-	log.Debug(ctx, "Streaming transcoded file", "id", mf.ID, "path", mf.Path,
-		"requestBitrate", bitRate, "requestFormat", format,
-		"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
-
-	f := &transcodedMediaStream{ctx: ctx, mf: mf, bitRate: bitRate, format: format}
-	return f, err
-}
-
-type rawMediaStream struct {
-	file *os.File
-	ctx  context.Context
-	mf   *model.MediaFile
-}
-
-func (m *rawMediaStream) Read(p []byte) (n int, err error) {
-	return m.file.Read(p)
-}
-
-func (m *rawMediaStream) Seek(offset int64, whence int) (int64, error) {
-	return m.file.Seek(offset, whence)
-}
-
-func (m *rawMediaStream) ContentType() string {
-	return m.mf.ContentType()
-}
-
-func (m *rawMediaStream) Name() string {
-	return m.mf.Path
-}
-
-func (m *rawMediaStream) ModTime() time.Time {
-	return m.mf.UpdatedAt
-}
-
-func (m *rawMediaStream) Close() error {
-	log.Trace(m.ctx, "Closing file", "id", m.mf.ID, "path", m.mf.Path)
-	return m.file.Close()
-}
-
-type transcodedMediaStream struct {
-	ctx     context.Context
-	mf      *model.MediaFile
-	pipe    io.ReadCloser
-	bitRate int
-	format  string
-	skip    int64
-	pos     int64
-}
-
-func (m *transcodedMediaStream) Read(p []byte) (n int, err error) {
-	// Open the pipe and optionally skip a initial chunk of the stream (to simulate a Seek)
-	if m.pipe == nil {
-		m.pipe, err = newTranscode(m.ctx, m.mf.Path, m.bitRate, m.format)
-		if err != nil {
-			return 0, err
-		}
-		if m.skip > 0 {
-			_, err := io.CopyN(ioutil.Discard, m.pipe, m.skip)
-			m.pos = m.skip
-			if err != nil {
-				return 0, err
-			}
-		}
-	}
-	n, err = m.pipe.Read(p)
-	m.pos += int64(n)
-	if err == io.EOF {
-		m.Close()
-	}
-	return
-}
-
-// This is an attempt to make a pipe seekable. It is very wasteful, restarting the stream every time
-// a Seek happens. This is ok-ish for audio, but would kill the server for video.
-func (m *transcodedMediaStream) Seek(offset int64, whence int) (int64, error) {
-	size := int64((m.mf.Duration)*m.bitRate*1000) / 8
-	log.Trace(m.ctx, "Seeking file", "path", m.mf.Path, "offset", offset, "whence", whence, "size", size)
-
-	switch whence {
-	case io.SeekEnd:
-		m.skip = size - offset
-		offset = size
-	case io.SeekStart:
-		m.skip = offset
-	case io.SeekCurrent:
-		io.CopyN(ioutil.Discard, m.pipe, offset)
-		m.pos += offset
-		offset = m.pos
-	}
-
-	// If need to Seek to a previous position, close the pipe (will be restarted on next Read)
-	var err error
-	if whence != io.SeekCurrent {
-		if m.pipe != nil {
-			err = m.Close()
-		}
-	}
-	return offset, err
-}
-
-func (m *transcodedMediaStream) ContentType() string {
-	return mime.TypeByExtension(".mp3")
-}
-
-func (m *transcodedMediaStream) Name() string {
-	return m.mf.Path
-}
-
-func (m *transcodedMediaStream) ModTime() time.Time {
-	return m.mf.UpdatedAt
-}
-
-func (m *transcodedMediaStream) Close() error {
-	log.Trace(m.ctx, "Closing stream", "id", m.mf.ID, "path", m.mf.Path)
-	err := m.pipe.Close()
-	m.pipe = nil
-	m.pos = 0
-	return err
-}
-
-func newTranscode(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
-	cmdLine, args := createTranscodeCommand(path, maxBitRate, format)
-
-	log.Trace(ctx, "Executing ffmpeg command", "arg0", cmdLine, "args", args)
-	cmd := exec.Command(cmdLine, args...)
-	cmd.Stderr = os.Stderr
-	if f, err = cmd.StdoutPipe(); err != nil {
-		return f, err
-	}
-	return f, cmd.Start()
-}
-
-func createTranscodeCommand(path string, maxBitRate int, format string) (string, []string) {
-	cmd := conf.Server.DownsampleCommand
-
-	split := strings.Split(cmd, " ")
-	for i, s := range split {
-		s = strings.Replace(s, "%s", path, -1)
-		s = strings.Replace(s, "%b", strconv.Itoa(maxBitRate), -1)
-		split[i] = s
-	}
-
-	return split[0], split[1:]
-}

engine/media_streamer_test.go

@@ -1,75 +0,0 @@
-package engine
-
-import (
-	"time"
-
-	"github.com/deluan/navidrome/conf"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/persistence"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("MediaStreamer", func() {
-
-	var streamer MediaStreamer
-	var ds model.DataStore
-	ctx := log.NewContext(nil)
-
-	BeforeEach(func() {
-		conf.Server.EnableDownsampling = true
-		ds = &persistence.MockDataStore{}
-		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "bitRate": 128}]`, 1)
-		streamer = NewMediaStreamer(ds)
-	})
-
-	Context("NewStream", func() {
-		It("returns a rawMediaStream if format is 'raw'", func() {
-			Expect(streamer.NewStream(ctx, "123", 0, "raw")).To(BeAssignableToTypeOf(&rawMediaStream{}))
-		})
-		It("returns a rawMediaStream if maxBitRate is 0", func() {
-			Expect(streamer.NewStream(ctx, "123", 0, "mp3")).To(BeAssignableToTypeOf(&rawMediaStream{}))
-		})
-		It("returns a rawMediaStream if maxBitRate is higher than file bitRate", func() {
-			Expect(streamer.NewStream(ctx, "123", 256, "mp3")).To(BeAssignableToTypeOf(&rawMediaStream{}))
-		})
-		It("returns a transcodedMediaStream if maxBitRate is lower than file bitRate", func() {
-			s, err := streamer.NewStream(ctx, "123", 64, "mp3")
-			Expect(err).To(BeNil())
-			Expect(s).To(BeAssignableToTypeOf(&transcodedMediaStream{}))
-			Expect(s.(*transcodedMediaStream).bitRate).To(Equal(64))
-		})
-	})
-
-	Context("rawMediaStream", func() {
-		var rawStream mediaStream
-		var modTime time.Time
-
-		BeforeEach(func() {
-			modTime = time.Now()
-			mf := &model.MediaFile{ID: "123", Path: "test.mp3", UpdatedAt: modTime, Suffix: "mp3"}
-			rawStream = &rawMediaStream{mf: mf, ctx: ctx}
-		})
-
-		It("returns the ContentType", func() {
-			Expect(rawStream.ContentType()).To(Equal("audio/mpeg"))
-		})
-
-		It("returns the ModTime", func() {
-			Expect(rawStream.ModTime()).To(Equal(modTime))
-		})
-	})
-
-	Context("createTranscodeCommand", func() {
-		BeforeEach(func() {
-			conf.Server.DownsampleCommand = "ffmpeg -i %s -b:a %bk mp3 -"
-		})
-		It("creates a valid command line", func() {
-			cmd, args := createTranscodeCommand("/music library/file.mp3", 123, "")
-			Expect(cmd).To(Equal("ffmpeg"))
-			Expect(args).To(Equal([]string{"-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
-		})
-
-	})
-})

engine/mock_nowplaying_repo.go

@@ -1,86 +0,0 @@
-package engine
-
-import (
-	"errors"
-	"time"
-)
-
-func CreateMockNowPlayingRepo() *MockNowPlaying {
-	return &MockNowPlaying{}
-}
-
-type MockNowPlaying struct {
-	NowPlayingRepository
-	data []NowPlayingInfo
-	t    time.Time
-	err  bool
-}
-
-func (m *MockNowPlaying) SetError(err bool) {
-	m.err = err
-}
-
-func (m *MockNowPlaying) Enqueue(info *NowPlayingInfo) error {
-	if m.err {
-		return errors.New("Error!")
-	}
-
-	m.data = append(m.data, NowPlayingInfo{})
-	copy(m.data[1:], m.data[0:])
-	m.data[0] = *info
-
-	if !m.t.IsZero() {
-		m.data[0].Start = m.t
-		m.t = time.Time{}
-	}
-
-	return nil
-}
-
-func (m *MockNowPlaying) Dequeue(playerId int) (*NowPlayingInfo, error) {
-	if len(m.data) == 0 {
-		return nil, nil
-	}
-	l := len(m.data)
-	info := m.data[l-1]
-	m.data = m.data[:l-1]
-
-	return &info, nil
-}
-
-func (m *MockNowPlaying) Count(playerId int) (int64, error) {
-	return int64(len(m.data)), nil
-}
-
-func (m *MockNowPlaying) GetAll() ([]*NowPlayingInfo, error) {
-	np, err := m.Head(1)
-	if np == nil || err != nil {
-		return nil, err
-	}
-	return []*NowPlayingInfo{np}, err
-}
-
-func (m *MockNowPlaying) Head(playerId int) (*NowPlayingInfo, error) {
-	if len(m.data) == 0 {
-		return nil, nil
-	}
-	info := m.data[0]
-	return &info, nil
-}
-
-func (m *MockNowPlaying) Tail(playerId int) (*NowPlayingInfo, error) {
-	if len(m.data) == 0 {
-		return nil, nil
-	}
-	info := m.data[len(m.data)-1]
-	return &info, nil
-}
-
-func (m *MockNowPlaying) ClearAll() {
-	m.data = make([]NowPlayingInfo, 0)
-	m.err = false
-}
-
-func (m *MockNowPlaying) OverrideNow(t time.Time) {
-	m.t = t
-}

engine/mock_property_repo.go

@@ -1,46 +0,0 @@
-package engine
-
-import (
-	"errors"
-
-	"github.com/deluan/navidrome/model"
-)
-
-func CreateMockPropertyRepo() *MockProperty {
-	return &MockProperty{data: make(map[string]string)}
-}
-
-type MockProperty struct {
-	model.PropertyRepository
-	data map[string]string
-	err  bool
-}
-
-func (m *MockProperty) SetError(err bool) {
-	m.err = err
-}
-
-func (m *MockProperty) Put(id string, value string) error {
-	if m.err {
-		return errors.New("Error!")
-	}
-	m.data[id] = value
-	return nil
-}
-
-func (m *MockProperty) Get(id string) (string, error) {
-	if m.err {
-		return "", errors.New("Error!")
-	}
-	return m.data[id], nil
-}
-
-func (m *MockProperty) DefaultGet(id string, defaultValue string) (string, error) {
-	v, err := m.Get(id)
-
-	if v == "" {
-		v = defaultValue
-	}
-
-	return v, err
-}

engine/ratings.go

@@ -1,71 +0,0 @@
-package engine
-
-import (
-	"context"
-
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
-)
-
-type Ratings interface {
-	SetStar(ctx context.Context, star bool, ids ...string) error
-	SetRating(ctx context.Context, id string, rating int) error
-}
-
-func NewRatings(ds model.DataStore) Ratings {
-	return &ratings{ds}
-}
-
-type ratings struct {
-	ds model.DataStore
-}
-
-func (r ratings) SetRating(ctx context.Context, id string, rating int) error {
-	exist, err := r.ds.Album(ctx).Exists(id)
-	if err != nil {
-		return err
-	}
-	if exist {
-		return r.ds.Album(ctx).SetRating(rating, id)
-	}
-	return r.ds.MediaFile(ctx).SetRating(rating, id)
-}
-
-func (r ratings) SetStar(ctx context.Context, star bool, ids ...string) error {
-	if len(ids) == 0 {
-		log.Warn(ctx, "Cannot star/unstar an empty list of ids")
-		return nil
-	}
-
-	return r.ds.WithTx(func(tx model.DataStore) error {
-		for _, id := range ids {
-			exist, err := r.ds.Album(ctx).Exists(id)
-			if err != nil {
-				return err
-			}
-			if exist {
-				err = tx.Album(ctx).SetStar(star, ids...)
-				if err != nil {
-					return err
-				}
-				continue
-			}
-			exist, err = r.ds.Artist(ctx).Exists(id)
-			if err != nil {
-				return err
-			}
-			if exist {
-				err = tx.Artist(ctx).SetStar(star, ids...)
-				if err != nil {
-					return err
-				}
-				continue
-			}
-			err = tx.MediaFile(ctx).SetStar(star, ids...)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	})
-}

engine/scrobbler.go

@@ -1,61 +0,0 @@
-package engine
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/deluan/navidrome/model"
-)
-
-type Scrobbler interface {
-	Register(ctx context.Context, playerId int, trackId string, playDate time.Time) (*model.MediaFile, error)
-	NowPlaying(ctx context.Context, playerId int, playerName, trackId, username string) (*model.MediaFile, error)
-}
-
-func NewScrobbler(ds model.DataStore, npr NowPlayingRepository) Scrobbler {
-	return &scrobbler{ds: ds, npRepo: npr}
-}
-
-type scrobbler struct {
-	ds     model.DataStore
-	npRepo NowPlayingRepository
-}
-
-func (s *scrobbler) Register(ctx context.Context, playerId int, trackId string, playTime time.Time) (*model.MediaFile, error) {
-	var mf *model.MediaFile
-	var err error
-	err = s.ds.WithTx(func(tx model.DataStore) error {
-		mf, err = s.ds.MediaFile(ctx).Get(trackId)
-		if err != nil {
-			return err
-		}
-		err = s.ds.MediaFile(ctx).IncPlayCount(trackId, playTime)
-		if err != nil {
-			return err
-		}
-		err = s.ds.Album(ctx).IncPlayCount(mf.AlbumID, playTime)
-		if err != nil {
-			return err
-		}
-		err = s.ds.Artist(ctx).IncPlayCount(mf.ArtistID, playTime)
-		return err
-	})
-	return mf, err
-}
-
-// TODO Validate if NowPlaying still works after all refactorings
-func (s *scrobbler) NowPlaying(ctx context.Context, playerId int, playerName, trackId, username string) (*model.MediaFile, error) {
-	mf, err := s.ds.MediaFile(ctx).Get(trackId)
-	if err != nil {
-		return nil, err
-	}
-
-	if mf == nil {
-		return nil, errors.New(fmt.Sprintf(`ID "%s" not found`, trackId))
-	}
-
-	info := &NowPlayingInfo{TrackID: trackId, Username: username, Start: time.Now(), PlayerId: playerId, PlayerName: playerName}
-	return mf, s.npRepo.Enqueue(info)
-}

engine/search.go

@@ -1,68 +0,0 @@
-package engine
-
-import (
-	"context"
-	"strings"
-
-	"github.com/deluan/navidrome/model"
-	"github.com/kennygrant/sanitize"
-)
-
-type Search interface {
-	SearchArtist(ctx context.Context, q string, offset int, size int) (Entries, error)
-	SearchAlbum(ctx context.Context, q string, offset int, size int) (Entries, error)
-	SearchSong(ctx context.Context, q string, offset int, size int) (Entries, error)
-}
-
-type search struct {
-	ds model.DataStore
-}
-
-func NewSearch(ds model.DataStore) Search {
-	s := &search{ds}
-	return s
-}
-
-func (s *search) SearchArtist(ctx context.Context, q string, offset int, size int) (Entries, error) {
-	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
-	artists, err := s.ds.Artist(ctx).Search(q, offset, size)
-	if len(artists) == 0 || err != nil {
-		return nil, nil
-	}
-
-	artistIds := make([]string, len(artists))
-	for i, al := range artists {
-		artistIds[i] = al.ID
-	}
-	return FromArtists(artists), nil
-}
-
-func (s *search) SearchAlbum(ctx context.Context, q string, offset int, size int) (Entries, error) {
-	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
-	albums, err := s.ds.Album(ctx).Search(q, offset, size)
-	if len(albums) == 0 || err != nil {
-		return nil, nil
-	}
-
-	albumIds := make([]string, len(albums))
-	for i, al := range albums {
-		albumIds[i] = al.ID
-	}
-
-	return FromAlbums(albums), nil
-}
-
-func (s *search) SearchSong(ctx context.Context, q string, offset int, size int) (Entries, error) {
-	q = sanitize.Accents(strings.ToLower(strings.TrimSuffix(q, "*")))
-	mediaFiles, err := s.ds.MediaFile(ctx).Search(q, offset, size)
-	if len(mediaFiles) == 0 || err != nil {
-		return nil, nil
-	}
-
-	trackIds := make([]string, len(mediaFiles))
-	for i, mf := range mediaFiles {
-		trackIds[i] = mf.ID
-	}
-
-	return FromMediaFiles(mediaFiles), nil
-}

engine/users.go

@@ -1,59 +0,0 @@
-package engine
-
-import (
-	"context"
-	"crypto/md5"
-	"encoding/hex"
-	"fmt"
-	"strings"
-
-	"github.com/deluan/navidrome/model"
-)
-
-type Users interface {
-	Authenticate(ctx context.Context, username, password, token, salt string) (*model.User, error)
-}
-
-func NewUsers(ds model.DataStore) Users {
-	return &users{ds}
-}
-
-type users struct {
-	ds model.DataStore
-}
-
-func (u *users) Authenticate(ctx context.Context, username, pass, token, salt string) (*model.User, error) {
-	user, err := u.ds.User(ctx).FindByUsername(username)
-	if err == model.ErrNotFound {
-		return nil, model.ErrInvalidAuth
-	}
-	if err != nil {
-		return nil, err
-	}
-	valid := false
-
-	switch {
-	case pass != "":
-		if strings.HasPrefix(pass, "enc:") {
-			if dec, err := hex.DecodeString(pass[4:]); err == nil {
-				pass = string(dec)
-			}
-		}
-		valid = pass == user.Password
-	case token != "":
-		t := fmt.Sprintf("%x", md5.Sum([]byte(user.Password+salt)))
-		valid = t == token
-	}
-
-	if !valid {
-		return nil, model.ErrInvalidAuth
-	}
-	// TODO: Find a way to update LastAccessAt without causing too much retention in the DB
-	//go func() {
-	//	err := u.ds.User(ctx).UpdateLastAccessAt(user.ID)
-	//	if err != nil {
-	//		log.Error(ctx, "Could not update user's lastAccessAt", "user", user.UserName)
-	//	}
-	//}()
-	return user, nil
-}

engine/users_test.go

@@ -1,54 +0,0 @@
-package engine
-
-import (
-	"context"
-
-	"github.com/deluan/navidrome/model"
-	"github.com/deluan/navidrome/persistence"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Users", func() {
-	Describe("Authenticate", func() {
-		var users Users
-		BeforeEach(func() {
-			ds := &persistence.MockDataStore{}
-			users = NewUsers(ds)
-		})
-
-		Context("Plaintext password", func() {
-			It("authenticates with plaintext password ", func() {
-				usr, err := users.Authenticate(context.TODO(), "admin", "wordpass", "", "")
-				Expect(err).NotTo(HaveOccurred())
-				Expect(usr).To(Equal(&model.User{UserName: "admin", Password: "wordpass"}))
-			})
-
-			It("fails authentication with wrong password", func() {
-				_, err := users.Authenticate(context.TODO(), "admin", "INVALID", "", "")
-				Expect(err).To(MatchError(model.ErrInvalidAuth))
-			})
-		})
-
-		Context("Encoded password", func() {
-			It("authenticates with simple encoded password ", func() {
-				usr, err := users.Authenticate(context.TODO(), "admin", "enc:776f726470617373", "", "")
-				Expect(err).NotTo(HaveOccurred())
-				Expect(usr).To(Equal(&model.User{UserName: "admin", Password: "wordpass"}))
-			})
-		})
-
-		Context("Token based authentication", func() {
-			It("authenticates with token based authentication", func() {
-				usr, err := users.Authenticate(context.TODO(), "admin", "", "23b342970e25c7928831c3317edd0b67", "retnlmjetrymazgkt")
-				Expect(err).NotTo(HaveOccurred())
-				Expect(usr).To(Equal(&model.User{UserName: "admin", Password: "wordpass"}))
-			})
-
-			It("fails if salt is missing", func() {
-				_, err := users.Authenticate(context.TODO(), "admin", "", "23b342970e25c7928831c3317edd0b67", "")
-				Expect(err).To(MatchError(model.ErrInvalidAuth))
-			})
-		})
-	})
-})

engine/wire_providers.go

@@ -1,16 +0,0 @@
-package engine
-
-import "github.com/google/wire"
-
-var Set = wire.NewSet(
-	NewBrowser,
-	NewCover,
-	NewListGenerator,
-	NewPlaylists,
-	NewRatings,
-	NewScrobbler,
-	NewSearch,
-	NewNowPlayingRepository,
-	NewUsers,
-	NewMediaStreamer,
-)

git/pre-commit

@@ -10,7 +10,11 @@
 #
 # This script does not handle file names that contain spaces.
 
-gofmtcmd=`which goimports || echo "gofmt"`
+if which goimports > /dev/null; then
+  gofmtcmd=goimports
+else
+  gofmtcmd=gofmt
+fi
 
 gofiles=$(git diff --cached --name-only --diff-filter=ACM | grep '.go$')
 [ -z "$gofiles" ] && exit 0
@@ -20,7 +24,7 @@ unformatted=$($gofmtcmd -l $gofiles)
 
 # Some files are not gofmt'd. Print message and fail.
 
-echo >&2 "Go files must be formatted with $gofmcmd. Please run:"
+echo >&2 "Go files must be formatted with '$gofmtcmd'. Please run:"
 for fn in $unformatted; do
 	echo >&2 "  $gofmtcmd -w $PWD/$fn"
 done

git/pre-push

@@ -0,0 +1,4 @@
+#!/bin/sh
+set -e
+
+make pre-push