Update Changelog

Bumps [github.com/tdewolff/minify/v2](https://github.com/tdewolff/minify) from 2.11.2 to 2.11.5.
- [Release notes](https://github.com/tdewolff/minify/releases)
- [Commits](https://github.com/tdewolff/minify/compare/v2.11.2...v2.11.5)

---
updated-dependencies:
- dependency-name: github.com/tdewolff/minify/v2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,10 @@
+---
+name: Bug report
+about: Create a bug report
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,10 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature request
+assignees: ''
+
+---
+
+- [ ] I have read this document: https://miniflux.app/opinionated.html#feature-request

.github/ISSUE_TEMPLATE/feed-problems.md

@@ -0,0 +1,10 @@
+---
+name: Feed Problems
+about: Problems with a feed or a website
+title: ''
+labels: feed problems
+assignees: ''
+
+---
+
+

.github/ISSUE_TEMPLATE/improvement.md

@@ -0,0 +1,10 @@
+---
+name: Improvement
+about: Do you have an idea to improve an existing feature?
+title: ''
+labels: improvements
+assignees: ''
+
+---
+
+

.github/ISSUE_TEMPLATE/installation-issue.md

@@ -0,0 +1,10 @@
+---
+name: Installation Issue
+about: Do you need help to install Miniflux?
+title: ''
+labels: installation issue
+assignees: ''
+
+---
+
+

.github/ISSUE_TEMPLATE/question---discussion.md

@@ -0,0 +1,10 @@
+---
+name: Question / Discussion
+about: Open discussions
+title: ''
+labels: question / discussion
+assignees: ''
+
+---
+
+

.github/dependabot.yml

@@ -0,0 +1,19 @@
+version: 2
+updates:
+  - package-ecosystem: "gomod"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    reviewers:
+      - "fguillot"
+    assignees:
+      - "fguillot"
+
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    reviewers:
+      - "fguillot"
+    assignees:
+      - "fguillot"

.github/pull_request_template.md

@@ -0,0 +1,4 @@
+Do you follow the guidelines?
+
+- [ ] I have tested my changes
+- [ ] I read this document: https://miniflux.app/faq.html#pull-request

.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI Workflow
+permissions: read-all
+
+on:
+  pull_request:
+    branches:
+    - master
+
+jobs:
+  unit-tests:
+    name: Unit Tests
+    runs-on: ${{ matrix.os }}
+    strategy:
+      max-parallel: 4
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        go-version: [1.16, 1.17, 1.18]
+    steps:
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: ${{ matrix.go-version }}
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Run unit tests
+      run: make test
+
+  integration-tests:
+    name: Integration Tests
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:9.5
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: postgres
+        ports:
+        - 5432:5432
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+    steps:
+    - name: Set up Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.16
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Install Postgres client
+      run: sudo apt-get install -y postgresql-client
+    - name: Run integration tests
+      run: make integration-test
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        PGHOST: 127.0.0.1
+        PGPASSWORD: postgres

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,72 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+permissions: read-all
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '45 22 * * 3'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go', 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/docker.yml

@@ -0,0 +1,81 @@
+name: Docker
+permissions: read-all
+on:
+  schedule:
+    - cron: '0 1 * * *'
+  push:
+    tags:
+      - '*.*.*'
+jobs:
+  docker-images:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+
+      - name: Generate Alpine Docker tag
+        id: docker_alpine_tag
+        run: |
+          DOCKER_IMAGE=miniflux/miniflux
+          DOCKER_VERSION=dev
+          if [ "${{ github.event_name }}" = "schedule" ]; then
+          DOCKER_VERSION=nightly
+          TAGS="${DOCKER_IMAGE}:${DOCKER_VERSION},ghcr.io/${DOCKER_IMAGE}:${DOCKER_VERSION}"
+          elif [[ $GITHUB_REF == refs/tags/* ]]; then
+          DOCKER_VERSION=${GITHUB_REF#refs/tags/}
+          TAGS="${DOCKER_IMAGE}:${DOCKER_VERSION},ghcr.io/${DOCKER_IMAGE}:${DOCKER_VERSION},${DOCKER_IMAGE}:latest,ghcr.io/${DOCKER_IMAGE}:latest"
+          fi
+          echo ::set-output name=tags::${TAGS}
+
+      - name: Generate Distroless Docker tag
+        id: docker_distroless_tag
+        run: |
+          DOCKER_IMAGE=miniflux/miniflux
+          DOCKER_VERSION=dev-distroless
+          if [ "${{ github.event_name }}" = "schedule" ]; then
+          DOCKER_VERSION=nightly-distroless
+          TAGS="${DOCKER_IMAGE}:${DOCKER_VERSION},ghcr.io/${DOCKER_IMAGE}:${DOCKER_VERSION}"
+          elif [[ $GITHUB_REF == refs/tags/* ]]; then
+          DOCKER_VERSION=${GITHUB_REF#refs/tags/}-distroless
+          TAGS="${DOCKER_IMAGE}:${DOCKER_VERSION},ghcr.io/${DOCKER_IMAGE}:${DOCKER_VERSION},${DOCKER_IMAGE}:latest-distroless,ghcr.io/${DOCKER_IMAGE}:latest-distroless"
+          fi
+          echo ::set-output name=tags::${TAGS}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1 
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v1 
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.CR_PAT }}
+
+      - name: Build and Push Alpine images
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./packaging/docker/alpine/Dockerfile
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
+          push: true
+          tags: ${{ steps.docker_alpine_tag.outputs.tags }}
+
+      - name: Build and Push Distroless images
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./packaging/docker/distroless/Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.docker_distroless_tag.outputs.tags }}

.github/workflows/linters.yml

@@ -0,0 +1,32 @@
+name: Linters
+permissions: read-all
+
+on:
+  pull_request:
+    branches:
+    - master
+
+jobs:
+  jshint:
+    name: Javascript Linter
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install jshint
+      run: |
+        sudo npm install -g jshint@2.13.3
+    - name: Run jshint
+      run: jshint ui/static/js/*.js
+
+  golangci:
+    name: Golang Linter
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-go@v2
+        with:
+          go-version: 1.17
+      - uses: golangci/golangci-lint-action@v2
+        with:
+          args: --skip-dirs tests --disable errcheck --enable sqlclosecheck --enable misspell --enable gofmt --enable goimports --enable whitespace
+          skip-go-installation: true

.github/workflows/scorecards-analysis.yml

@@ -0,0 +1,55 @@
+name: Scorecards supply-chain security
+on:
+  # Only the default branch is supported.
+  branch_protection_rule:
+  schedule:
+    - cron: '31 8 * * 6'
+  push:
+    branches: [ master ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecards analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      actions: read
+      contents: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@ec3a7ce113134d7a93b817d10a8272cb61118579 # v2.4.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@e3e75cf2ffbf9364bbff86cdbdf52b23176fe492 # v1.0.1
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # Read-only PAT token. To create it,
+          # follow the steps in https://github.com/ossf/scorecard-action#pat-token-creation.
+          repo_token: ${{ secrets.SCORECARD_READ_TOKEN }}
+          # Publish the results to enable scorecard badges. For more details, see
+          # https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories, `publish_results` will automatically be set to `false`,
+          # regardless of the value entered here.
+          publish_results: true
+
+      # Upload the results as artifacts (optional).
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@82c141cc518b40d92cc801eee768e7aafc9c2fa2 # v2.3.1
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@5f532563584d71fdef14ee64d17bafb34f751ce5 # v1.0.26
+        with:
+          sarif_file: results.sarif

.gitignore

@@ -1,4 +1,5 @@
-miniflux-linux-amd64
-miniflux-linux-arm*
-miniflux-darwin-amd64
-miniflux-test
+miniflux-*
+miniflux
+*.rpm
+*.deb
+.idea

.travis.yml

@@ -1,17 +0,0 @@
-notifications:
-  email: false
-services:
-  - postgresql
-addons:
-  postgresql: "9.4"
-language: go
-go:
-  - 1.9
-before_install:
-  - npm install -g jshint
-  - go get -u github.com/golang/lint/golint
-script:
-  - jshint ui/static/js/app.js
-  - make lint
-  - make test
-  - make integration-test

ChangeLog

@@ -1,3 +1,879 @@
+Version 2.0.37 (May 27, 2022)
+-----------------------------
+
+* Add rewrite rule to decode base64 content
+* Add Linkding integration
+* Add comment button to Telegram message
+* Add API endpoint to fetch unread and read counters
+* Fixes logic bug in Google Reader API sanity check
+* Reduce number of CORS preflight check to save network brandwidth
+* Add Espial integration
+* Allow API search for entries which are not starred
+* Try to use outermost element text when title is empty
+* Make swipe gestures feel more natural
+    - Removes opacity transition when swiping an article read/unread
+    - Adds "resistance" to the swiped entry when the 75px threshold is
+    reached
+    - Fixes an issue in which a swiped article couldn't be moved <15px
+* Add support for feed streams to Google Reader API IDs API
+* Fix invalid parsing of icon data URL
+* Add Traditional Chinese translation
+* Add distroless Docker image variant
+* Add Go 1.18 to GitHub Action
+* Bump `github.com/tdewolff/minify/v2` from `2.10.0` to `2.11`
+* Bump `github.com/prometheus/client_golan` from `1.12.1` to `1.12.2`
+* Bump `github.com/lib/pq` from `1.10.4` to `1.10.6`
+
+Version 2.0.36 (March 8, 2022)
+------------------------------
+
+* Gray out pagination buttons when they are not applicable
+* Use truncated entry description as title if unavailable
+* Do not fallback to InnerXML if XHTML title is empty
+* Add `+` keyboard shortcut for new subscription page
+* Add `(+)` action next to Feeds to quickly add new feeds
+* Fix unstar not working via Google Reader API
+* Remove circles in front of page header list items
+* Fix CSS hover style for links styled as buttons
+* Avoid showing `undefined` when clicking on read/unread
+* Add new keyboard shortcut `M` to toggle read/unread, and go to previous item
+* Add several icons to menus according to their roles
+* Add missing event argument to `onClick()` function call
+* Add links to scraper/rewrite/filtering docs when editing feeds
+* Add a rewrite rule for Castopod episodes
+* Fix regression: reset touch-item if not in `/unread` page
+* Add API endpoint to fetch original article
+* Show the category first in feed settings
+* Add pagination on top of all entries
+* Display Go version in "About" page
+* Bump `mvdan.cc/xurls/v2` from 2.3.0 to 2.4.0
+* Bump `github.com/prometheus/client_golang` from 1.11.0 to 1.12.1
+* Bump `github.com/tdewolff/minify/v2` from 2.9.28 to 2.10.0
+
+Version 2.0.35 (January 21, 2022)
+---------------------------------
+
+* Set `read-all` permission to `GITHUB_TOKEN` for GitHub Actions
+* Pin `jshint` version in linter job
+* Fix incorrect conversion between integer types
+* Add new GitHub Actions workflows: CodeQL and Scorecards analysis
+* Handle Atom feeds with space around CDATA
+* Bump `github.com/tdewolff/minify/v2` from 2.9.22 to 2.9.28
+* Add Documentation directive to Systemd service
+* Do not reset `touch-item` if successfully swiped
+* Add support for multiple authors in Atom feeds
+* Omit `User-Agent` header in image proxy to avoid being blocked
+* Use custom feed user agent to fetch website icon
+* Make default Invidious instance configurable
+* Add new rewrite rule `add_youtube_video_from_id` to add Youtube videos in Quanta articles
+* Add scrape and rewrite rules for `quantamagazine.org`
+* Expose entry unshare link in the entry and list views
+* Add Google Reader API implementation (experimental)
+* Add `Content-Security-Policy` header to feed icon and image proxy endpoints
+    - SVG images could contain Javascript. This CSP blocks inline script.
+    - Feed icons are served using `<img>` tag and Javascript is not interpreted.
+* Add Finnish translation
+* Add scraper rule for `ikiwiki.iki.fi`
+* Remove `SystemCallFilter` from `miniflux.service`
+* Fix minor typo in French translation
+
+Version 2.0.34 (December 16, 2021)
+----------------------------------
+
+* Add rewrite rule for comics website http://monkeyuser.com
+* Add `<head>` tag to OPML export
+* Tighten Systemd sandboxing and update comments in `miniflux.service`
+* Add `RuntimeDirectory` to Systemd service
+* Order disabled feeds at the end of the list
+* Add support for theme color based on preferred color scheme of OS
+* Bump `github.com/lib/pq` from 1.10.3 to 1.10.4
+* Bump `github.com/PuerkitoBio/goquery` from 1.7.1 to 1.8.0
+* Fix typos in `model/icon.go`
+* Add `data-srcset` support to `add_dynamic_image rewrite` rewrite rule
+* Fix Docker Compose example files compatibility to v3
+* Added the `role="article"` to `<article>` elements for better accessibility with screen readers
+* Redact secrets shown on the about page
+* Handle `srcset` images with no space after comma
+* Hide the logout link when using auth proxy
+* Fix wrong CSS variable
+* Change `-config-dump` command to use `KEY=VALUE` format
+
+Version 2.0.33 (September 25, 2021)
+-----------------------------------
+
+* Build RPM and Debian package with PIE mode enabled
+* Add CSS rule to hide `<template>` tag in old browsers
+* Bump `github.com/tdewolff/minify/v2 from 2.9.21 to 2.9.22`
+* Bump `github.com/lib/pq from 1.10.2 to 1.10.3`
+* Remove `RequestURI()` hack
+* Improve `zh_CN` translation
+* Add ability to change entry sort order in the UI
+* Add minor improvements in integration package
+* Add Telegram integration
+* Add rewrite rule to remove DOM elements
+* Add proxy argument to `scraper.Fetch()`
+* Add mime type `application/feed+json` to discover JSON Feed v1.1
+* Update scraper rule for `theregister.com`
+* Add Go 1.17 to GitHub Actions
+* Display option to hide feed only when category is not already hidden
+* Add option to hide feeds from the global Unread list
+
+Version 2.0.32 (August 14, 2021)
+--------------------------------
+
+* Bump `github.com/tdewolff/minify/v2` from 2.9.17 to 2.9.21
+* Bump `mvdan.cc/xurls/v2` from 2.2.0 to 2.3.0
+* Bump `github.com/PuerkitoBio/goquery` from 1.6.1 to 1.7.1
+* Bump `github.com/prometheus/client_golang` from 1.10.0 to 1.11.0
+* Add `/rss/` to the list of well known URLs during feed discovery
+* Use `authors` entry for JSON 1.1 feeds
+* Added Greek translation
+* Added the ability to mark an entire category as read in the web ui
+* Added "in" in "logged in" for en_US `tooltip.logged_user`
+* Added option to hide categories from the global unread list
+* Show "saving" labels for entry status button
+* Golang client: Try to parse response body on `InternalServerError` errors
+* contrib: Add support for a $MINIFLUX_IMAGE env var in docker-compose
+* contrib: Bump docker-compose version to 3.4
+
+Version 2.0.31 (June 6, 2021)
+-----------------------------
+
+* Expose comments_url entry field in Golang API client
+* Use unique file names for cache busting instead of query string
+* Highlight and sort feeds with unread entries in feeds list
+* Mark items as read on click/middle click of external links
+* Fix: Firefox on Windows does not show the active link as bold
+* Avoid extra HTTP request for fetching custom stylesheet
+* Remove invalid CSRF HTML meta tag
+* Add lang attribute to root HTML tag
+* Use runes instead of bytes to truncate JSON feed titles (avoid breaking Unicode strings)
+* Expose changed_at time through the API
+* Add new config option CLEANUP_ARCHIVE_BATCH_SIZE
+* Add new option DATABASE_CONNECTION_LIFETIME
+* Add database stats to Prometheus exporter
+* Add Systemd watchdog
+* Avoid custom stylesheet to be cached by third-party CDN
+* Update a shared entry label translation in zh_CN
+* Bump github.com/tdewolff/minify/v2 from 2.9.16 to 2.9.17
+* Bump github.com/lib/pq from 1.10.1 to 1.10.2
+
+Version 2.0.30 (May 7, 2021)
+----------------------------
+
+* Security fix: any user can delete any feed (Regression introduced in commit 51fb949)
+* Fix password reset via CLI
+* Increase default batch size value
+* Handle RSS feed title with encoded Unicode entities
+* Show number of unread per category in category list instead of number of feeds
+* Bump github.com/lib/pq from 1.10.0 to 1.10.1
+* Filtering doesn't work when selecting from multiple found feeds
+* Bump github.com/tdewolff/minify/v2 from 2.9.15 to 2.9.16
+* Use an appropriate color for visited links on dark theme
+* Fix typo in reader/json/doc.go
+* Create SECURITY.md
+* Setup golangci-lint Github Action
+* Add per feed cookies option
+* Bump github.com/prometheus/client_golang from 1.9.0 to 1.10.0
+* Bump github.com/tdewolff/minify/v2 from 2.9.13 to 2.9.15
+
+Version 2.0.29 (Mar 21, 2021)
+-----------------------------
+
+* Miniflux requires at least Go 1.16 now
+* Improved support of Atom text constructs
+    - Improve handling of CDATA in text elements
+    - Omit XHTML root element because it should not be part of the content
+    - Fix incorrect parsing of HTML elements
+* Handle RDF feed with HTML encoded entry title
+* Add Turkish language
+* Improve deletion of feeds with lots of entries
+* Add support of Systemd readiness notification using the sd_notify protocol
+* Remove feed_icons service worker cache because it's causing more problems than it solves (and HTTP cache seems faster)
+* Add basic PWA offline page
+    - Add basic offline mode when using the service worker
+    - Starting in Chrome 93, offline mode is going to be a requirement to install the PWA
+* Replace icon for "Add to home screen" button
+* Use SVG icons for "toast" notifications
+* Use SVG sprite for icons instead of inline elements
+* Reset scroll position on mark page as read
+* Add link to mark all feed entries as read
+* Make web app display mode configurable (The change is visible after reinstalling the web app)
+* Handle RSS feeds with CDATA in author item element
+* Add read time on the article page
+* Avoid showing a broken image when there is no feed icon
+* Add option to allow self-signed or invalid certificates
+* Add new config option to scrape YouTube's website to get video duration as read time (disabled by default)
+* Send full article content to Wallabag
+* Add more extensive health check support
+    - Improve endpoint to test database connection
+    - Add new cli argument: -healthcheck
+    - Update Docker Compose examples
+* Update iframe "allow list" to support Bilibili videos
+* Remove completely generated files and use embed package to bundle JS/CSS/Images/Translations files into the final binary
+* Remove deprecated io/ioutil package
+* Show Postgres version in "About" page
+
+Version 2.0.28 (Feb 15, 2021)
+-----------------------------
+
+* Add HTTP header "Referrer-Policy: no-referrer"
+* Handle entry title with double encoded entities
+* Add Open Containers annotations to Docker image
+* Remove iframe inner HTML contents (iframe element never has fallback content)
+* Update date parser to fix another time zone issue
+* Update German translation for blocklist and keeplist
+* Validate Keep list and Block list rules syntax
+* Add support for IPv6 with zone index
+* Allow images with data URLs
+* Limit full-text search indexation to first 500K characters (tsvector has a size limit of 1MB)
+* Change PWA display mode to standalone
+* ETag value is not set correctly in HTTP client (regression)
+* Add database backed Let's Encrypt certificate cache
+* Add global option POLLING_PARSING_ERROR_LIMIT
+* Update systemd service file comments to use `systemctl edit` for editing
+* Update Go version to 1.15 in go.mod
+* Don't discard the "Fetch via Proxy" option
+* Update man page to show the default values
+* Add PostgreSQL indices
+* Add API endpoints to get feeds and entries of a category
+* Create feed query builder
+* Bump github.com/PuerkitoBio/goquery from 1.6.0 to 1.6.1
+* Show global options in the about page
+* Update man page to mention -1 can be used for CLEANUP_ARCHIVE_* options
+
+Version 2.0.27 (Jan 9, 2021)
+----------------------------
+
+* Add spellcheck="false" to input fields
+* Refactoring of entry, feed, category, and user validation
+* Avoid stripping tags for entry title
+* Add the possibility to subscribe to feeds with the Android Share menu
+* API improvements:
+    - Change feed creation request to allow setting most fields via API
+    - Allow regular users to change settings via API
+    - Make user fields editable via API
+    - Renaming non-existent category via API should return a 404
+* Update Systemd service file:
+    - Add capability CAP_NET_BIND_SERVICE (allow the process to listen on privileged ports)
+    - Enable a private /tmp for $CERT_CACHE (required when using Let's Encrypt)
+* Update read/star icons to SVGs
+* Add autocomplete="username" to HTML forms
+* Improve user mass delete to use fewer Goroutines
+* Use SQL transaction when creating user sessions and users
+* Remove extra column (HSTORE field) from users table and migrate key/value pairs to specific columns
+* Bump github.com/prometheus/client_golang from 1.8.0 to 1.9.0
+* Bump github.com/lib/pq from 1.8.0 to 1.9.0
+* Add styles for <abbr> HTML tag
+* Refactor SQL migrations:
+    - Avoid embedding SQL files into binary
+    - Allow more flexible changes by using Go functions
+* Add Server-Timing header to unread page
+* Show correct User Agent in input placeholders
+* Add autocomplete attribute to login form
+* Add Grafana dashboard in contrib folder
+
+Version 2.0.26 (Dec 5, 2020)
+----------------------------
+
+* Use created_at instead of published_at for archiving entries
+* Add created_at field for entries
+* Handle invalid feeds with relative URLs
+* Add API routes for "mark all as read"
+* Add support for setting a global default User-Agent
+* Add rewrite rule "replace" for custom search and replace
+* Calculate reading time during feed processing
+* Handle various invalid dates
+* systemd: keep /run writeable
+* debian package: add missing post-install script
+* Do not follow redirects when trying known feed URLs
+* Trim spaces around icon URLs
+* Reinstate EXPOSE instruction in Dockerfile
+* Update German and Portuguese translations
+
+Version 2.0.25 (Nov 3, 2020)
+----------------------------
+
+* Rename "original" link to be more explicit
+* Do not escape HTML for Atom 1.0 text content during parsing (Avoid HTML entities issues)
+* Do not use charset.NewReader if the body is a valid UTF-8 document
+* Restore the ability to use a proxy for all HTTP requests (see https://golang.org/pkg/net/http/#ProxyFromEnvironment)
+* Show Git commit in about page
+* Publish Docker images to GitHub Container Registry
+* Added few Docker Compose examples in contrib folder
+* Added Ansible Role + Playbook for Miniflux in contrib folder
+* Add rewrite rule to use noscript content for images rendered with Javascript
+* Bump github.com/prometheus/client_golang from 1.7.1 to 1.8.0
+* Update contributor link and Godoc badge for API client
+* Move Debian package builder to main repository
+* Move RPM build files to main repository
+* Add GitHub Action to generate Docker images
+* Build multi-platform images with Docker Buildx
+* Add keyboard shortcut to scroll current item to the top
+* Add feed filters (Keeplist and Blocklist)
+* Do not proxy image with a data URL
+* Bump github.com/PuerkitoBio/goquery from 1.5.1 to 1.6.0
+* Proxify articles crawled manually
+* Proxify images defined in srcset attribute
+* Remove plaintext Fever password from database
+* Add keyboard shortcut to jump to an item's feed page
+* Add option for swipe gesture on entries on mobile
+
+Version 2.0.24 (Oct 3, 2020)
+----------------------------
+
+* Add rewrite rule to fix Medium.com images
+* Update sanitizer to support responsive images:
+    - Add support for picture HTML tag
+    - Add support for srcset, media, and sizes attributes to img and source tags
+* Enhance man page formatting
+* Add Prometheus exporter
+* Remove dependency on global config options in HTTP client
+* API:
+    - Avoid database lookup if empty credentials are provided
+    - Add the possibility to filter entries by category ID
+    - Add the possibility to filter entries by a list of statuses
+* Add Feed ID in worker error logs
+* Tweak default HTTP client transport timeout values to reduce the number of file descriptors
+* CSS tweaks and optimizations:
+    - Prevent sub and sup from affecting line-height
+    - Set touch-action on .items to prevent browser navigation
+    - Move font-family specific CSS to the appropriate file
+    - Update primary font-family for UI to be even more compatible with various operating systems
+    - Make .entry-content font-weight variable depending on font-family used
+* Avoid Javascript minifier to break keyboard shortcuts
+* Rename service worker script to avoid being blocked by uBlock
+* Update date parser to handle Pacific Daylight Time in addition to Pacific Standard Time
+* Create index to speed up bookmark page
+* Do not try to update a duplicated feed after a refresh
+* Use a transaction to refresh and create entries
+* Speed up entries clean up with an index and a goroutine
+* Avoid the accumulation of enclosures by keeping only what is referenced in the feed
+* Add workarounds for parsing an invalid date
+* Archive older entries first
+* Update API client to support more filters
+* Avoid duplication between get feed entries and get entries API endpoints
+* Enable strict slash to avoid a page not found (404) when using a trailing slash in the URLs
+* Add a submit button to each section of the integration page
+* Reload page after making page as read when showing unread entries
+* Add option to archive unread entries
+* Add option to enable maintenance mode
+* Add HTTP proxy option for subscriptions
+* Make add_invidious_video rule applicable for different invidious instances
+* Fix reading time for jp, ko and zh languages
+* Update POLLING_SCHEDULER description in man page
+* Bump gorilla/mux from 1.7.4 to 1.8.0
+* Add link to mark a feed as read
+
+Version 2.0.23 (Aug 15, 2020)
+-----------------------------
+
+* Try known URLs when discovering subscriptions
+* Add workarounds to find YouTube channel feeds (YouTube doesn't expose RSS links anymore for new-style URLs)
+* Increase HTTP server timeout values
+* Use stdlib constants for HTTP methods instead of strings
+* Add support for RTL feed content
+* Ignore <media:title> to avoid overriding the default title if they are different
+* Add support for secret keys exposed as a file (useful for containerized environments)
+* Display recent entries first in search results
+* Do not archive shared items
+* Add option to change the number of entries per page
+* Add Brazilian Portuguese (pt_BR) translation
+* Add reading time for entries
+* Redirect to login page if CSRF token is expired
+* Fever API:
+    - Use getEntryIDs instead of getEntries to reduce memory consumption
+    - Fix max_id argument logic to follow the specs
+    - Improve logging
+    - Do not send articles to external services when unsaving an item
+    - Create index to speed up API calls
+    - Log client IP in middleware
+* API client: Do not return body for response with no content
+* REST API:
+    - Delete users asynchronously (Deleting large users might lock the tables)
+    - Add CORS support
+* Align entry actions to the left
+    - Attempt to avoid awkward alignment on smartphone screens
+    - Keep the read/star actions aligned to the left
+    - Remove CSS flex to allow easier override with custom CSS
+* Upgrade Postgres client library
+* Upgrade CI checks to Go 1.15
+
+Version 2.0.22 (Jun 19, 2020)
+-----------------------------
+
+* Remove child-src CSP policy (deprecated)
+* Add /version endpoint
+* Add the ability to use custom css
+* Handle more invalid dates
+* Add CSS styles for textarea
+* Add index to speed up slow query
+* Speed up feed list page rendering
+* Add alternative scheduler based on the number of entries
+* Setup Dependabot on GitHub
+* Update Docker image to Alpine 3.12
+* Add feed option to ignore HTTP cache
+* Fix some Italian and German translations
+* Added scraper rule for RayWenderlich.com, TheOatmeal.com, financialsamurai.com, dilbert.com and turnoff.us
+* Replace link to categories by a link to the list of entries in "Category > Feeds" page
+* Change feed title to a link to the original website
+* Add icons to feeds and categories list
+* Update dependencies and remove vendor folder
+
+Version 2.0.21 (Mar 28, 2020)
+-----------------------------
+
+* Add SVG icons to entry actions
+* Add support for Invidious
+    - Embed Invidious player for invidio.us feeds
+    - Add new rewrite rule to use Invidious player for Youtube feeds
+* Check during application startup if the database schema is up to date
+* Change default theme for public pages to "System Serif"
+* Add feature to share an article (create a public link of a feed entry)
+* Fix SQL injection in full-text search rank ordering
+* Add generic OpenID Connect provider (OAuth2)
+* Use more secure TLS configuration for autocert server (increase SSL Labs score from B to A+)
+* Add feature to create per-application API Keys
+* Add Go 1.14 to GitHub Actions
+* Add scraper rule for wdwnt.com
+* Add API client function to refresh all feeds
+* Add API endpoint to refresh all feeds
+* Add Auth Proxy authentication
+* Use rel=prev/next on pagination links
+
+Version 2.0.20 (Feb 15, 2020)
+-----------------------------
+
+* Add Japanese translation
+* History: show entries in the order in which they were read
+* Add button to add to Home screen
+* Ignore enclosures without URL
+* Correct spelling of "toggle"
+* List view: align information to the left side, and the actionable buttons to the right
+* Redirect to /unread when getting a 404 for an unread expired entry
+* Do not advance to the next item when using the 'v' shortcut on the list of starred items
+* Wrap around when navigating with keyboard shortcuts on a list view
+* Remove unused Feed.Entries and Entry.Category from API client
+* Add comments link keyboard shortcut
+* Allow application/xhtml+xml links as comments URL in Atom replies
+* Allow only absolute URLs in comments URL
+* Use internal XML workarounds to detect feed format
+* Make menu consistent across feed pages
+* Make sure external URLs are not encoded incorrectly by Go template engine
+* Make sure whitelisted URI schemes are handled properly by the sanitizer
+* Use white background for favicon (Improve legibility when using a dark theme)
+* Remove dependency on Sed to build Docker images
+* Normalize URL query string before executing HTTP requests
+* Improve Dublin Core support for RDF feeds
+* Improve Podcast support (iTunes and Google Play feeds)
+* Add support for Atom 0.3
+* Add support for Atom "replies" link relation
+* Return outer HTML when scraping elements
+* Update scraper rule for "Le Monde"
+* Filter valid XML characters for UTF-8 XML documents before decoding
+* Trim spaces for RDF entry links
+
+Version 2.0.19 (Dec 1, 2019)
+----------------------------
+
+* Add shortcut "V" to open original link in current tab
+* Add the possibility to add rules during feed creation
+* Wrap attachments into <details> disclosure element
+* Show attachment size on entry page
+* Add support of RSS Media elements (group, description, peer link, and thumbnails)
+* Add rewrite functions: convert_text_link and nl2br
+* Add scraper rule for openingsource.org
+* Add Makefile target to build only amd64 Docker image
+* Make sure to remove integration settings when removing a user
+* Add API parameter to filter entries by category
+* Display list of feeds per category
+* Show the number of read and unread entries for each feed
+* Make sure settings menu is consistent
+* Remove fixed table-layout for entry content
+* Update autocert lib because ACME v1 is EOL
+* Do not lighten blockquote font color
+* Update de_DE translation
+* Send a response when changing status of removed entries in Fever API
+* Add meta tag to disable Google Translate
+* Improve storage module
+* Improve XML decoder to remove illegal characters
+* Compare Fever token case-insensitively
+* Make sure integration tests are marked as failed in Github Actions
+* Add new formats to date parser
+* Add notification message when using keyboard shortcuts: f, s, and m.
+* Avoid keyboard shortcuts to conflict with Firefox’s "Find as you type" feature
+
+Version 2.0.18 (Sep 25, 2019)
+-----------------------------
+
+* Add Docker image variant for arm32v7
+* Add theme variants
+    - Use CSS variables instead of inherence
+    - Rename default theme to "Light - Serif"
+    - Rename Black theme to "Dark - Serif"
+    - Rename "Sans-Serif" theme to "Light - Sans Serif"
+    - Add "System" theme that use system preferences: Dark or Light
+    - Add Serif and Sans-Serif variants for each color theme
+* Avoid constraint error when having duplicate entries during feed creation
+* Disable strict XML parsing
+* Ignore invalid content type
+* Update man page
+* Replace Travis by GitHub Actions
+* Rename cleanup config variables and deprecate old ones
+    - CLEANUP_FREQUENCY_HOURS instead of CLEANUP_FREQUENCY
+    - CLEANUP_ARCHIVE_READ_DAYS instead of ARCHIVE_READ_DAYS
+* Make configurable the number of days to remove old sessions
+* Add native lazy loading for images and iframes
+* Do not buffer responses in the image proxy
+* Update dependencies
+* Add Go 1.13 to test matrix
+* Replace link border by outline to avoid slight content shift
+* New rewrite function: add_mailto_subject
+* Import OPML from URL
+* Fix HTML injection in addImageTitle
+* Accept HTML entities when parsing XML
+
+Version 2.0.17 (Aug 3, 2019)
+----------------------------
+
+* Update Docker image to Alpine Linux 3.10.1
+* Pass auth header to manifest request (crossorigin attribute)
+* Sort feed categories before serialization
+* Fix syntax errors in man page
+* Add .search margin-right
+* Ask for confirmation before flushing history, marking page as read, and mark all as read
+* Add option to disable feeds
+
+Version 2.0.16 (Jun 8, 2019)
+----------------------------
+
+* Add option to toggle date/time in log messages
+* Add optional config file parser in addition to environment variables
+* Make HTTP Client timeout and max body size configurable
+* Refactor config package:
+    - Parse configuration only once during startup time
+    - Store configuration values in a global variable
+* Flip behavior of j and k keyboard shortcuts
+* Bump Postgresql client library to v1.1.1 to bring in SCRAM-SHA-256 authentication
+* Add option to enable/disable keyboard shortcuts
+* Add missing translation
+* Improve page reload when showing unread/all entries:
+    - Show only unread entries = refresh current page
+    - Show all entries = go to next page
+* Always display feed entries even when there is a feed error
+* Use loading label instead of saving when submitting login form
+* Add OPML v1 support during importation
+* Add 'allow-popups' to iframe sandbox permissions
+
+Version 2.0.15 (Mar 16, 2019)
+-----------------------------
+
+* Move Dockerfile to main repo
+* Change location of the binary from /usr/local/bin to /usr/bin in Docker image
+* Add double tap detection for next/previous page navigation
+* Allow users to disable auto-remove
+* Make parser compatible with Go 1.12
+* Add Golang 1.12 to CI
+* Use feed ID instead of user ID to check entry URLs presence
+* Fix typo in stylesheet
+* Sort search results by relevance
+* Use preferably the published date for Atom feeds
+* Add Spanish translation
+* Rename session cookies
+* Handle the case when application session is expired and not user session
+
+Version 2.0.14 (Jan 13, 2019)
+-----------------------------
+
+* Only attempt to change password if the confirmation field is filled in (Firefox)
+* Remove URL from client user agent
+* Make the feed list order case-insensitive
+* Handle XHTML Summary elements for Atom feeds
+* Make UTF-8 the default encoding for XML feeds
+* Add more targets to Makefile
+* Add -mod=vendor in Makefile
+* Move health check endpoint from ui package to httpd service
+* Add workaround for non GMT dates (RFC822, RFC850, and RFC1123)
+* Make sure `<strong>` elements are bold
+* Show scrollbars only when necessary for <pre> elements
+* Add Italian translation
+* Allow to switch between unread only and all entries on category/feed views
+* Add function storage.UpdateFeedError()
+* Add BBC News scraping rule
+* Ignore JSON feeds from EnsureUnicode()
+* Preserve category selection when no feed is found
+* Update XML encoding regex to take single quotes into consideration
+* Send cli errors to stderr
+* Update dependencies
+* Make password prompt compatible with Windows
+* Make configurable the number of days to archive read items
+* Change log level to debug when starting workers
+* Do not show $DATABASE_URL warning when showing application info
+* Move image proxy filter to template functions
+* Update scraper rule for lemonde.fr
+* Refactor manual entry scraper
+* Apply rewriter rules on manual "Fetch Original Content"
+* Add Makefile target for current OS and architecture
+* Improve Makefile
+
+Version 2.0.13 (Nov 25, 2018)
+-----------------------------
+
+* Add man page
+* Add support for Systemd Socket Activation (experimental)
+* Add the possibility to listen on Unix sockets
+* Add config options to disable HTTP and scheduler services
+* Archive more read entries in cleanup job
+* Change default database connection string (backward compatible)
+* Improve logging messages in ui package
+* Improve overall Simplified Chinese translations
+* Improve time since post date displays:
+    - "15 days" now is "15 days" rather than "3 weeks" ago
+    - "32 days" is now "1 month" rather than "2 months" ago
+    - "366 days" is now "1 year" rather than "2 years" ago
+* Allow the scraper to parse XHTML documents
+* Remove charset=utf-8 from JSON responses
+* Ignore hotkeys containing Control, Alt or Meta keys
+* Handle more encoding conversion edge cases
+* Disable go test caching
+* Avoid duplication of ldflags in Makefile
+* Fix wrong translation key for category pages
+* Code refactoring:
+    - Simplify application HTTP middlewares
+    - Replace daemon and scheduler package with service package
+    - Move UI middlewares and routes to ui package
+    - Move API middleware and routes to api package
+    - Move Fever middleware and routes to fever package
+
+Version 2.0.12 (Oct 26, 2018)
+-----------------------------
+
+* Add OpenBSD build
+* Improve logging for OAuth2 callback
+* Make "g f" go to feed, or list of feeds
+* Add more details in feed storage errors to facilitate debugging
+* Add entries storage error to feed errors count
+* Set arbitrary maximum size for tsvector column
+* Unsubscribe from feed through link or "#"
+* Simplify feed entries filtering
+* Simplify feed fetcher
+* Simplify feed parser and format detection
+* Improve unit tests in url package
+* Add short cli flags -i and -v
+* Convert text links and line feeds to HTML in YouTube channels
+* Change link state when marking all entries as read
+* Add missing package descriptions for GoDoc
+* Fix typo in license header
+* Refactor HTTP response builder
+* Improve Fever API performances when marking a feed or group as read
+* Set focus on article link when pressing prev/next hotkeys
+* Improve request package and add more unit tests
+* Add more unit tests for config package
+* Simplify locale package usage (refactoring)
+* Translate application in Russian
+* Use disclosure widget <details> for advanced feed options
+* Use unique translation IDs instead of English text as key
+* Add more unit tests for template functions
+* Fix invalid output when truncating Unicode text in templates
+* Add the possibility to override default user agent for each feed
+* Split Makefile linux targets by architecture
+* Add compiler, Arch, and OS to info command
+* Avoid line break between emoji and (un)read/(un)star links
+* Build Docker image for multiple architectures (amd64, arm32v6, arm64v8)
+
+Version 2.0.11 (Sep 11, 2018)
+-----------------------------
+
+* Set cookie flag `SameSite` to Lax mode
+* Use predefined ciphers when TLS is configured
+* Avoid displaying an error when shutting down the daemon
+* Add "Mark this page as read" to the bottom
+* Store client IP address in request context
+* Refactor HTTP context handling
+* Make user creation via environment variables idempotent
+* Use regular text version of ✔︎ instead of emoji version on iOS
+* Add toggle status button to entry page
+* Migrate to Go Modules and Go 1.11
+* Show count of feeds with permanent errors in header menu
+* Display remote client IP in logs when having a login failure (Fail2Ban)
+* Add remove button in feed edit page
+* Split integration tests into multiple files
+* Update scraper rule for heise.de
+* Expose real error messages for internal server API errors
+* Move Golang API client in project source tree (the separate project is deprecated)
+* Use canonical imports
+* Add Procfile
+* Create database package (refactoring)
+* Update user agent with new website URL
+* Update German translation
+
+Version 2.0.10 (July 22, 2018)
+------------------------------
+
+* Avoid browser caching issues when assets changes
+* Add Gzip/Deflate compression for HTML, JSON, CSS and Javascript responses
+* Improve themes handling
+    * Store user theme in session
+    * Logged out users will keep their theme
+    * Add theme background color to web manifest and meta tag
+* Update application icon with different sizes
+* Add support for published tag in Atom feeds
+* Add tooltip to feed domain in feeds list (title attribute)
+* Prevent vertical scrolling on swipe
+* Show feed title instead of domain in items list
+* Add service worker to cache feed icons
+* Make image proxy configurable via IMAGE_PROXY environment variable:
+    * none = No proxy
+    * http-only = Proxy only non-HTTPS images (default)
+    * all = Proxy everything
+* Add alt attribute for feed icons
+* Update CI jshint check
+* Add embedly.com to iframe whitelist
+* Use passive event listeners for touch events
+* Add `add_dynamic_image` rewriter for JavaScript-loaded images
+* Change feed password field type to text to avoid auto-completion with Firefox
+    * Using autocomplete="off" or autocomplete="new-password" doesn't change anything
+    * Changing the input ID doesn't change anything
+    * Using a different input name doesn't change anything
+    * Only Chrome supports autocomplete="new-password"
+* Add base URL validation
+* Update default stylesheet name in HTML layout
+* Pre-generate themes stylesheets at build time
+* Update vendor dependencies
+* Refactor assets bundler and split Javascript files
+* Run sanitizer after all processing and entry content rewrite
+* Remove timestamp from generated files
+* Add support for protocol relative YouTube URLs
+* Add Postgres full-text search for entries
+* Add search form in user interface
+* Add search parameter to the API
+* Improve Dutch locales
+* Sandbox iframes when sanitizing
+* Keep consistent text size on mobile orientation change
+* Change permission of /etc/miniflux.conf to 600 instead of 644 in RPM package
+* Add tzdata package to Docker image
+* Update Docker image to Alpine Linux 3.8
+
+Version 2.0.9 (July 1, 2018)
+----------------------------
+
+* Avoid Chrome to autocomplete no-login password fields
+* Add cli flag to reset all feed errors
+* Do not ignore errored feeds when a user refresh feeds manually
+* Add specific 404 and 401 error messages
+* Strip binaries to reduce size
+* Make sure we always get the pagination in unread mode
+* Fix incorrect data value when toggling bookmark flag on entry page
+* Set opener to null when opening original URL with JavaScript
+* Remove unnecessary style
+* Refactor AddImageTitle rewriter
+    * Only processes images with `src` **and** `title` attributes (others are ignored)
+    * Processes **all** images in the document (not just the first one)
+    * Wraps the image and its title attribute in a `figure` tag with the title attribute's contents in a `figcaption` tag
+* Improve sanitizer to remove `style`, `noscript` and `script` tag contents
+* Improve feed and user API updates with optional values
+* Add new fields for feed username/password
+* Improve memory usage debug log
+* Disable keep-alive for HTTP client
+* Close HTTP response body even for failed requests
+* Add Sans-Serif theme
+* Rewrite iframe Youtube URLs to https://www.youtube-nocookie.com
+* Add more filters for API call `/entries`:
+    * before (unix timestamp)
+    * before_entry_id (int64)
+    * after (unix timestamp)
+    * after_entry_id (int64)
+    * starred (boolean)
+* Rewrite individual entry pagination SQL queries
+* Simplify entry query builder
+* Prevent items from sticking on touchend
+* Extended horizontal overflow to feed and category views
+* Translate missing strings
+* Update German translation
+
+Version 2.0.8 (June 4, 2018)
+----------------------------
+
+* Add Pocket integration
+* Rewrite RealIP() to avoid returning an empty string
+* Convert IP field from text to inet type
+* Improve error handling in integration clients
+* Make unread counter clickable
+* Archive read entries automatically after 60 days
+* Hide horizontal overflow when swiping articles on touch devices
+* Add API endpoint to get logged user
+* Fever API: Return response with an empty list if there is no item
+* Handle feeds with dates formatted as Unix timestamp
+
+Version 2.0.7 (May 7, 2018)
+---------------------------
+
+* Add API endpoint to import OPML file
+* Make sure to close request body in HTTP client
+* Do not show save link if no integration is configured
+* Make sure integrations are configured before to make any HTTP requests
+* Avoid people to unlink their OAuth2 account without having a local password
+* Do not use shared variable to translate templates (avoid concurrency issue)
+* Use vanilla HTTP handlers (refactoring)
+* Move HTTP client to its own package (refactoring)
+* Add middleware to read X-Forwarded-Proto header (refactoring)
+* Use Gorilla middleware (refactoring)
+* Scrape parent element for iframe
+* Add SoundCloud and Bandcamp iframe sources
+
+Version 2.0.6 (Apr 20, 2018)
+----------------------------
+
+* Improve graceful shutdown
+* Simplify Heroku deployment
+* Display memory usage and some metrics in logs
+* Increase read/write timeout for HTTP server
+* Add support for Dublin Core date in RDF feeds
+* Do not return an error if the user session is not found
+* Handle some non-english date formats
+* Add missing French translation
+* Rename RSS parser getters
+* Get the right comments URL when having multiple namespaces
+* Ignore caching headers for feeds that send "Expires: 0"
+* Update translations
+
+Version 2.0.5 (Apr 7, 2018)
+---------------------------
+
+* Avoid unread counter to be off by one when reading an entry
+* Add Comments URL to entries
+* Add FreeBSD build target
+* Handle RSS author elements with inner HTML
+* Fix typo in translations
+* Add Dutch translation
+* Convert enclosure size field to bigint
+* Switch CI to Go v1.10
+* Fix broken OPML import when compiling with Go 1.10
+
+Version 2.0.4 (Mar 5, 2018)
+---------------------------
+
+* Add Simplified Chinese translation
+* Add Nunux Keeper integration
+* Filter the list of timezones
+* Add timezone to entries dates for REST and Fever API
+* Show last login and session creation date in current timezone
+* Fix typo in edit user template
+* Improve parser error messages
+* Remove parentheses around feed error messages
+* Support localized feed errors generated by background workers
+* Print info message if DATABASE_URL is not set
+
+Version 2.0.3 (Feb 19, 2018)
+----------------------------
+
+* Add Polish translation
+* Change color of <q> tags for black theme
+* Add database indexes (don't forget to run database migrations)
+* Handle Atom feeds with HTML title
+* Strip invalid XML characters to avoid parsing errors
+* Improve error handling for HTTP client
+
 Version 2.0.2 (Feb 5, 2018)
 ---------------------------
 

Gopkg.lock

@@ -1,163 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  name = "github.com/PuerkitoBio/goquery"
-  packages = ["."]
-  revision = "e1271ee34c6a305e38566ecd27ae374944907ee9"
-  version = "v1.1.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/andybalholm/cascadia"
-  packages = ["."]
-  revision = "349dd0209470eabd9514242c688c403c0926d266"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/golang/protobuf"
-  packages = ["proto"]
-  revision = "1e59b77b52bf8e4b449a57e6f79f21226d571845"
-
-[[projects]]
-  name = "github.com/gorilla/context"
-  packages = ["."]
-  revision = "1ea25387ff6f684839d82767c1733ff4d4d15d0a"
-  version = "v1.1"
-
-[[projects]]
-  name = "github.com/gorilla/mux"
-  packages = ["."]
-  revision = "7f08801859139f86dfafd1c296e2cba9a80d292e"
-  version = "v1.6.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/lib/pq"
-  packages = [
-    ".",
-    "hstore",
-    "oid"
-  ]
-  revision = "83612a56d3dd153a94a629cd64925371c9adad78"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/miniflux/miniflux-go"
-  packages = ["."]
-  revision = "887ba3b062946784f0e64edb1734f435beb204f9"
-
-[[projects]]
-  name = "github.com/tdewolff/minify"
-  packages = [
-    ".",
-    "css",
-    "js"
-  ]
-  revision = "222672169d634c440a73abc47685074e1a9daa60"
-  version = "v2.3.4"
-
-[[projects]]
-  name = "github.com/tdewolff/parse"
-  packages = [
-    ".",
-    "buffer",
-    "css",
-    "js",
-    "strconv"
-  ]
-  revision = "639f6272aec6b52094db77b9ec488214b0b4b1a1"
-  version = "v2.3.2"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/tomasen/realip"
-  packages = ["."]
-  revision = "b5850897b7b539a1c9f22cdaa3b547d1bd453db8"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/crypto"
-  packages = [
-    "acme",
-    "acme/autocert",
-    "bcrypt",
-    "blowfish",
-    "ssh/terminal"
-  ]
-  revision = "1875d0a70c90e57f11972aefd42276df65e895b9"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/net"
-  packages = [
-    "context",
-    "context/ctxhttp",
-    "html",
-    "html/atom",
-    "html/charset"
-  ]
-  revision = "d866cfc389cec985d6fda2859936a575a55a3ab6"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/oauth2"
-  packages = [
-    ".",
-    "internal"
-  ]
-  revision = "462316686f20eb6df426961c1c131bdaa5dfa68e"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/sys"
-  packages = [
-    "unix",
-    "windows"
-  ]
-  revision = "571f7bbbe08da2a8955aed9d4db316e78630e9a3"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/text"
-  packages = [
-    "encoding",
-    "encoding/charmap",
-    "encoding/htmlindex",
-    "encoding/internal",
-    "encoding/internal/identifier",
-    "encoding/japanese",
-    "encoding/korean",
-    "encoding/simplifiedchinese",
-    "encoding/traditionalchinese",
-    "encoding/unicode",
-    "internal/gen",
-    "internal/tag",
-    "internal/utf8internal",
-    "language",
-    "runes",
-    "transform",
-    "unicode/cldr"
-  ]
-  revision = "d5a9226ed7dd70cade6ccae9d37517fe14dd9fee"
-
-[[projects]]
-  name = "google.golang.org/appengine"
-  packages = [
-    "internal",
-    "internal/base",
-    "internal/datastore",
-    "internal/log",
-    "internal/remote_api",
-    "internal/urlfetch",
-    "urlfetch"
-  ]
-  revision = "150dc57a1b433e64154302bdc40b6bb8aefa313a"
-  version = "v1.0.0"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  inputs-digest = "338222e5111416c46b2b8bde149443abc542b386dd02aff2a0dd6e13334bcf28"
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

@@ -1,58 +0,0 @@
-
-# Gopkg.toml example
-#
-# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
-# for detailed Gopkg.toml documentation.
-#
-# required = ["github.com/user/thing/cmd/thing"]
-# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
-#
-# [[constraint]]
-#   name = "github.com/user/project"
-#   version = "1.0.0"
-#
-# [[constraint]]
-#   name = "github.com/user/project2"
-#   branch = "dev"
-#   source = "github.com/myfork/project2"
-#
-# [[override]]
-#  name = "github.com/x/y"
-#  version = "2.4.0"
-
-
-[[constraint]]
-  name = "github.com/PuerkitoBio/goquery"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "github.com/gorilla/mux"
-  version = "1.6.0"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/lib/pq"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/miniflux/miniflux-go"
-
-[[constraint]]
-  name = "github.com/tdewolff/minify"
-  version = "2.3.3"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/tomasen/realip"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/crypto"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/net"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/oauth2"

Makefile

@@ -1,53 +1,167 @@
-APP := miniflux
-VERSION=$(shell git rev-parse --short HEAD)
-BUILD_DATE=`date +%FT%T%z`
-PKG_LIST := $(shell go list ./... | grep -v /vendor/)
-DB_URL := postgres://postgres:postgres@localhost/miniflux_test?sslmode=disable
+APP          := miniflux
+DOCKER_IMAGE := miniflux/miniflux
+VERSION      := $(shell git describe --tags --abbrev=0)
+COMMIT       := $(shell git rev-parse --short HEAD)
+BUILD_DATE   := `date +%FT%T%z`
+LD_FLAGS     := "-s -w -X 'miniflux.app/version.Version=$(VERSION)' -X 'miniflux.app/version.Commit=$(COMMIT)' -X 'miniflux.app/version.BuildDate=$(BUILD_DATE)'"
+PKG_LIST     := $(shell go list ./... | grep -v /vendor/)
+DB_URL       := postgres://postgres:postgres@localhost/miniflux_test?sslmode=disable
+DEB_IMG_ARCH := amd64
 
-.PHONY: linux linux-arm darwin build run clean test lint integration-test clean-integration-test
+export PGPASSWORD := postgres
 
-linux:
-	@ go generate
-	@ GOOS=linux GOARCH=amd64 go build -ldflags="-X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-linux-amd64 main.go
+.PHONY: \
+	miniflux \
+	linux-amd64 \
+	linux-arm64 \
+	linux-armv7 \
+	linux-armv6 \
+	linux-armv5 \
+	linux-x86 \
+	darwin-amd64 \
+	darwin-arm64 \
+	freebsd-amd64 \
+	freebsd-x86 \
+	openbsd-amd64 \
+	openbsd-x86 \
+	netbsd-x86 \
+	netbsd-amd64 \
+	windows-amd64 \
+	windows-x86 \
+	build \
+	run \
+	clean \
+	test \
+	lint \
+	integration-test \
+	clean-integration-test \
+	docker-image \
+	docker-image-distroless \
+	docker-images \
+	rpm \
+	debian \
+	debian-packages
 
-linux-arm:
-	@ go generate
-	@ GOOS=linux GOARCH=arm64 go build -ldflags="-X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-linux-armv8 main.go
-	@ GOOS=linux GOARCH=arm GOARM=7 go build -ldflags="-X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-linux-armv7 main.go
-	@ GOOS=linux GOARCH=arm GOARM=6 go build -ldflags="-X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-linux-armv6 main.go
-	@ GOOS=linux GOARCH=arm GOARM=5 go build -ldflags="-X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-linux-armv5 main.go
+miniflux:
+	@ go build -buildmode=pie -ldflags=$(LD_FLAGS) -o $(APP) main.go
 
-darwin:
-	@ go generate
-	@ GOOS=darwin GOARCH=amd64 go build -ldflags="-X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-darwin-amd64 main.go
+linux-amd64:
+	@ GOOS=linux GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-amd64 main.go
 
-build: linux linux-arm darwin
+linux-arm64:
+	@ GOOS=linux GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-arm64 main.go
+
+linux-armv7:
+	@ GOOS=linux GOARCH=arm GOARM=7 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-armv7 main.go
+
+linux-armv6:
+	@ GOOS=linux GOARCH=arm GOARM=6 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-armv6 main.go
+
+linux-armv5:
+	@ GOOS=linux GOARCH=arm GOARM=5 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-armv5 main.go
+
+darwin-amd64:
+	@ GOOS=darwin GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-darwin-amd64 main.go
+
+darwin-arm64:
+	@ GOOS=darwin GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-darwin-arm64 main.go
+
+freebsd-amd64:
+	@ GOOS=freebsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-freebsd-amd64 main.go
+
+openbsd-amd64:
+	@ GOOS=openbsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-openbsd-amd64 main.go
+
+windows-amd64:
+	@ GOOS=windows GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-windows-amd64 main.go
+
+build: linux-amd64 linux-arm64 linux-armv7 linux-armv6 linux-armv5 darwin-amd64 darwin-arm64 freebsd-amd64 openbsd-amd64 windows-amd64
+
+# NOTE: unsupported targets
+netbsd-amd64:
+	@ GOOS=netbsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-netbsd-amd64 main.go
+
+linux-x86:
+	@ GOOS=linux GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-x86 main.go
+
+freebsd-x86:
+	@ GOOS=freebsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-freebsd-x86 main.go
+
+netbsd-x86:
+	@ GOOS=netbsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-netbsd-x86 main.go
+
+openbsd-x86:
+	@ GOOS=openbsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-freebsd-x86 main.go
+
+windows-x86:
+	@ GOOS=windows GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-windows-x86 main.go
 
 run:
-	@ go generate
-	@ go run main.go -debug
+	@ LOG_DATE_TIME=1 go run main.go -debug
 
 clean:
-	@ rm -f $(APP)-*
+	@ rm -f $(APP)-* $(APP) $(APP)*.rpm $(APP)*.deb
 
 test:
-	go test -cover -race ./...
+	go test -cover -race -count=1 ./...
 
 lint:
-	@ golint -set_exit_status ${PKG_LIST}
+	golint -set_exit_status ${PKG_LIST}
 
 integration-test:
 	psql -U postgres -c 'drop database if exists miniflux_test;'
 	psql -U postgres -c 'create database miniflux_test;'
-	DATABASE_URL=$(DB_URL) go run main.go -migrate
-	DATABASE_URL=$(DB_URL) ADMIN_USERNAME=admin ADMIN_PASSWORD=test123 go run main.go -create-admin
 	go build -o miniflux-test main.go
-	DATABASE_URL=$(DB_URL) ./miniflux-test -debug >/tmp/miniflux.log 2>&1 & echo "$$!" > "/tmp/miniflux.pid"
-	while ! echo exit | nc localhost 8080; do sleep 1; done >/dev/null
-	go test -v -tags=integration || cat /tmp/miniflux.log
+
+	DATABASE_URL=$(DB_URL) \
+	ADMIN_USERNAME=admin \
+	ADMIN_PASSWORD=test123 \
+	CREATE_ADMIN=1 \
+	RUN_MIGRATIONS=1 \
+	DEBUG=1 \
+	./miniflux-test >/tmp/miniflux.log 2>&1 & echo "$$!" > "/tmp/miniflux.pid"
+	
+	while ! nc -z localhost 8080; do sleep 1; done
+	go test -v -tags=integration -count=1 miniflux.app/tests
 
 clean-integration-test:
 	@ kill -9 `cat /tmp/miniflux.pid`
 	@ rm -f /tmp/miniflux.pid /tmp/miniflux.log
 	@ rm miniflux-test
 	@ psql -U postgres -c 'drop database if exists miniflux_test;'
+
+docker-image:
+	docker build -t $(DOCKER_IMAGE):$(VERSION) -f packaging/docker/alpine/Dockerfile .
+
+docker-image-distroless:
+	docker build -t $(DOCKER_IMAGE):$(VERSION) -f packaging/docker/distroless/Dockerfile .
+
+docker-images:
+	docker buildx build \
+		--platform linux/amd64,linux/arm64,linux/arm/v7,linux/arm/v6 \
+		--file packaging/docker/alpine/Dockerfile \
+		--tag $(DOCKER_IMAGE):$(VERSION) \
+		--push .
+
+rpm: clean
+	@ docker build \
+		-t miniflux-rpm-builder \
+		-f packaging/rpm/Dockerfile \
+		.
+	@ docker run --rm \
+		-v ${PWD}:/root/rpmbuild/RPMS/x86_64 miniflux-rpm-builder \
+		rpmbuild -bb --define "_miniflux_version $(VERSION)" /root/rpmbuild/SPECS/miniflux.spec
+
+debian:
+	@ docker build \
+		--build-arg BASE_IMAGE_ARCH=$(DEB_IMG_ARCH) \
+		-t $(DEB_IMG_ARCH)/miniflux-deb-builder \
+		-f packaging/debian/Dockerfile \
+		.
+	@ docker run --rm \
+		-v ${PWD}:/pkg $(DEB_IMG_ARCH)/miniflux-deb-builder
+
+debian-packages: clean
+	$(MAKE) debian DEB_IMG_ARCH=amd64
+	$(MAKE) debian DEB_IMG_ARCH=arm64v8
+	$(MAKE) debian DEB_IMG_ARCH=arm32v7

Procfile

@@ -0,0 +1 @@
+web: miniflux.app

README.md

@@ -1,8 +1,5 @@
 Miniflux 2
 ==========
-[![Build Status](https://travis-ci.org/miniflux/miniflux.svg?branch=master)](https://travis-ci.org/miniflux/miniflux)
-[![GoDoc](https://godoc.org/github.com/miniflux/miniflux?status.svg)](https://godoc.org/github.com/miniflux/miniflux)
-[![Documentation Status](https://readthedocs.org/projects/miniflux/badge/?version=latest)](https://docs.miniflux.net/)
 
 Miniflux is a minimalist and opinionated feed reader:
 
@@ -11,26 +8,47 @@ Miniflux is a minimalist and opinionated feed reader:
 - Doesn't use any ORM
 - Doesn't use any complicated framework
 - Use only modern vanilla Javascript (ES6 and Fetch API)
+- Single binary compiled statically without dependency
 - The number of features is voluntarily limited
 
 It's simple, fast, lightweight and super easy to install.
 
-Miniflux 2 is a rewrite of [Miniflux 1.x](https://github.com/miniflux/miniflux-legacy) in Golang.
+Official website: <https://miniflux.app>
 
 Documentation
 -------------
 
-The Miniflux documentation is available here: <https://docs.miniflux.net/>
+The Miniflux documentation is available here: <https://miniflux.app/docs/> ([Man page](https://miniflux.app/miniflux.1.html))
 
-- [Opinionated?](https://docs.miniflux.net/en/latest/opinionated.html)
-- [Features](https://docs.miniflux.net/en/latest/features.html)
-- [Requirements](https://docs.miniflux.net/en/latest/requirements.html)
-- [Installation](https://docs.miniflux.net/en/latest/installation.html)
-- [Upgrading to a new version](https://docs.miniflux.net/en/latest/upgrade.html)
-- [Configuration](https://docs.miniflux.net/en/latest/configuration.html)
+- [Opinionated?](https://miniflux.app/opinionated.html)
+- [Features](https://miniflux.app/features.html)
+- [Requirements](https://miniflux.app/docs/requirements.html)
+- [Installation Instructions](https://miniflux.app/docs/installation.html)
+- [Upgrading to a New Version](https://miniflux.app/docs/upgrade.html)
+- [Configuration](https://miniflux.app/docs/configuration.html)
+- [Command Line Usage](https://miniflux.app/docs/cli.html)
+- [User Interface Usage](https://miniflux.app/docs/ui.html)
+- [Keyboard Shortcuts](https://miniflux.app/docs/keyboard_shortcuts.html)
+- [Integration with External Services](https://miniflux.app/docs/services.html)
+- [Rewrite and Scraper Rules](https://miniflux.app/docs/rules.html)
+- [API Reference](https://miniflux.app/docs/api.html)
+- [Development](https://miniflux.app/docs/development.html)
+- [Internationalization](https://miniflux.app/docs/i18n.html)
+- [Frequently Asked Questions](https://miniflux.app/faq.html)
+
+Screenshots
+-----------
+
+Default theme:
+
+![Default theme](https://miniflux.app/images/overview.png)
+
+Dark theme when using keyboard navigation:
+
+![Dark theme](https://miniflux.app/images/item-selection-black-theme.png)
 
 Credits
 -------
 
-- Author: Frédéric Guillot
+- Authors: Frédéric Guillot - [List of contributors](https://github.com/miniflux/v2/graphs/contributors)
 - Distributed under Apache 2.0 License

SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+## Supported Versions
+
+Only the latest stable version is supported.
+
+## Reporting a Vulnerability
+
+Send an email to `security AT miniflux DOT net` with all the steps to reproduce the problem.

api/api.go

@@ -0,0 +1,67 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package api // import "miniflux.app/api"
+
+import (
+	"net/http"
+
+	"miniflux.app/storage"
+	"miniflux.app/worker"
+
+	"github.com/gorilla/mux"
+)
+
+type handler struct {
+	store *storage.Storage
+	pool  *worker.Pool
+}
+
+// Serve declares API routes for the application.
+func Serve(router *mux.Router, store *storage.Storage, pool *worker.Pool) {
+	handler := &handler{store, pool}
+
+	sr := router.PathPrefix("/v1").Subrouter()
+	middleware := newMiddleware(store)
+	sr.Use(middleware.handleCORS)
+	sr.Use(middleware.apiKeyAuth)
+	sr.Use(middleware.basicAuth)
+	sr.Methods(http.MethodOptions)
+	sr.HandleFunc("/users", handler.createUser).Methods(http.MethodPost)
+	sr.HandleFunc("/users", handler.users).Methods(http.MethodGet)
+	sr.HandleFunc("/users/{userID:[0-9]+}", handler.userByID).Methods(http.MethodGet)
+	sr.HandleFunc("/users/{userID:[0-9]+}", handler.updateUser).Methods(http.MethodPut)
+	sr.HandleFunc("/users/{userID:[0-9]+}", handler.removeUser).Methods(http.MethodDelete)
+	sr.HandleFunc("/users/{userID:[0-9]+}/mark-all-as-read", handler.markUserAsRead).Methods(http.MethodPut)
+	sr.HandleFunc("/users/{username}", handler.userByUsername).Methods(http.MethodGet)
+	sr.HandleFunc("/me", handler.currentUser).Methods(http.MethodGet)
+	sr.HandleFunc("/categories", handler.createCategory).Methods(http.MethodPost)
+	sr.HandleFunc("/categories", handler.getCategories).Methods(http.MethodGet)
+	sr.HandleFunc("/categories/{categoryID}", handler.updateCategory).Methods(http.MethodPut)
+	sr.HandleFunc("/categories/{categoryID}", handler.removeCategory).Methods(http.MethodDelete)
+	sr.HandleFunc("/categories/{categoryID}/mark-all-as-read", handler.markCategoryAsRead).Methods(http.MethodPut)
+	sr.HandleFunc("/categories/{categoryID}/feeds", handler.getCategoryFeeds).Methods(http.MethodGet)
+	sr.HandleFunc("/categories/{categoryID}/entries", handler.getCategoryEntries).Methods(http.MethodGet)
+	sr.HandleFunc("/categories/{categoryID}/entries/{entryID}", handler.getCategoryEntry).Methods(http.MethodGet)
+	sr.HandleFunc("/discover", handler.discoverSubscriptions).Methods(http.MethodPost)
+	sr.HandleFunc("/feeds", handler.createFeed).Methods(http.MethodPost)
+	sr.HandleFunc("/feeds", handler.getFeeds).Methods(http.MethodGet)
+	sr.HandleFunc("/feeds/counters", handler.fetchCounters).Methods(http.MethodGet)
+	sr.HandleFunc("/feeds/refresh", handler.refreshAllFeeds).Methods(http.MethodPut)
+	sr.HandleFunc("/feeds/{feedID}/refresh", handler.refreshFeed).Methods(http.MethodPut)
+	sr.HandleFunc("/feeds/{feedID}", handler.getFeed).Methods(http.MethodGet)
+	sr.HandleFunc("/feeds/{feedID}", handler.updateFeed).Methods(http.MethodPut)
+	sr.HandleFunc("/feeds/{feedID}", handler.removeFeed).Methods(http.MethodDelete)
+	sr.HandleFunc("/feeds/{feedID}/icon", handler.feedIcon).Methods(http.MethodGet)
+	sr.HandleFunc("/feeds/{feedID}/mark-all-as-read", handler.markFeedAsRead).Methods(http.MethodPut)
+	sr.HandleFunc("/export", handler.exportFeeds).Methods(http.MethodGet)
+	sr.HandleFunc("/import", handler.importFeeds).Methods(http.MethodPost)
+	sr.HandleFunc("/feeds/{feedID}/entries", handler.getFeedEntries).Methods(http.MethodGet)
+	sr.HandleFunc("/feeds/{feedID}/entries/{entryID}", handler.getFeedEntry).Methods(http.MethodGet)
+	sr.HandleFunc("/entries", handler.getEntries).Methods(http.MethodGet)
+	sr.HandleFunc("/entries", handler.setEntryStatus).Methods(http.MethodPut)
+	sr.HandleFunc("/entries/{entryID}", handler.getEntry).Methods(http.MethodGet)
+	sr.HandleFunc("/entries/{entryID}/bookmark", handler.toggleBookmark).Methods(http.MethodPut)
+	sr.HandleFunc("/entries/{entryID}/fetch-content", handler.fetchContent).Methods(http.MethodGet)
+}

api/category.go

@@ -2,102 +2,124 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package api
+package api // import "miniflux.app/api"
 
 import (
-	"errors"
+	json_parser "encoding/json"
+	"net/http"
+	"time"
 
-	"github.com/miniflux/miniflux/http/handler"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/model"
+	"miniflux.app/validator"
 )
 
-// CreateCategory is the API handler to create a new category.
-func (c *Controller) CreateCategory(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	category, err := decodeCategoryPayload(request.Body())
+func (h *handler) createCategory(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+
+	var categoryRequest model.CategoryRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&categoryRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
+
+	if validationErr := validator.ValidateCategoryCreation(h.store, userID, &categoryRequest); validationErr != nil {
+		json.BadRequest(w, r, validationErr.Error())
+		return
+	}
+
+	category, err := h.store.CreateCategory(userID, &categoryRequest)
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	category.UserID = userID
-	if err := category.ValidateCategoryCreation(); err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	if c, err := c.store.CategoryByTitle(userID, category.Title); err != nil || c != nil {
-		response.JSON().BadRequest(errors.New("This category already exists"))
-		return
-	}
-
-	err = c.store.CreateCategory(category)
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to create this category"))
-		return
-	}
-
-	response.JSON().Created(category)
+	json.Created(w, r, category)
 }
 
-// UpdateCategory is the API handler to update a category.
-func (c *Controller) UpdateCategory(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	categoryID, err := request.IntegerParam("categoryID")
+func (h *handler) updateCategory(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	categoryID := request.RouteInt64Param(r, "categoryID")
+
+	category, err := h.store.Category(userID, categoryID)
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	category, err := decodeCategoryPayload(request.Body())
+	if category == nil {
+		json.NotFound(w, r)
+		return
+	}
+
+	var categoryRequest model.CategoryRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&categoryRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
+
+	if validationErr := validator.ValidateCategoryModification(h.store, userID, category.ID, &categoryRequest); validationErr != nil {
+		json.BadRequest(w, r, validationErr.Error())
+		return
+	}
+
+	categoryRequest.Patch(category)
+	err = h.store.UpdateCategory(category)
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	category.UserID = ctx.UserID()
-	category.ID = categoryID
-	if err := category.ValidateCategoryModification(); err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	err = c.store.UpdateCategory(category)
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to update this category"))
-		return
-	}
-
-	response.JSON().Created(category)
+	json.Created(w, r, category)
 }
 
-// GetCategories is the API handler to get a list of categories for a given user.
-func (c *Controller) GetCategories(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	categories, err := c.store.Categories(ctx.UserID())
+func (h *handler) markCategoryAsRead(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	categoryID := request.RouteInt64Param(r, "categoryID")
+
+	category, err := h.store.Category(userID, categoryID)
 	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch categories"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	response.JSON().Standard(categories)
+	if category == nil {
+		json.NotFound(w, r)
+		return
+	}
+
+	if err = h.store.MarkCategoryAsRead(userID, categoryID, time.Now()); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.NoContent(w, r)
 }
 
-// RemoveCategory is the API handler to remove a category.
-func (c *Controller) RemoveCategory(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	categoryID, err := request.IntegerParam("categoryID")
+func (h *handler) getCategories(w http.ResponseWriter, r *http.Request) {
+	categories, err := h.store.Categories(request.UserID(r))
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	if !c.store.CategoryExists(userID, categoryID) {
-		response.JSON().NotFound(errors.New("Category not found"))
-		return
-	}
-
-	if err := c.store.RemoveCategory(userID, categoryID); err != nil {
-		response.JSON().ServerError(errors.New("Unable to remove this category"))
-		return
-	}
-
-	response.JSON().NoContent()
+	json.OK(w, r, categories)
+}
+
+func (h *handler) removeCategory(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	categoryID := request.RouteInt64Param(r, "categoryID")
+
+	if !h.store.CategoryIDExists(userID, categoryID) {
+		json.NotFound(w, r)
+		return
+	}
+
+	if err := h.store.RemoveCategory(userID, categoryID); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.NoContent(w, r)
 }

api/controller.go

@@ -1,21 +0,0 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package api
-
-import (
-	"github.com/miniflux/miniflux/reader/feed"
-	"github.com/miniflux/miniflux/storage"
-)
-
-// Controller holds all handlers for the API.
-type Controller struct {
-	store       *storage.Storage
-	feedHandler *feed.Handler
-}
-
-// NewController creates a new controller.
-func NewController(store *storage.Storage, feedHandler *feed.Handler) *Controller {
-	return &Controller{store: store, feedHandler: feedHandler}
-}

api/doc.go

@@ -1,10 +0,0 @@
-// Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
-
-/*
-
-Package api implements API endpoints for Miniflux application.
-
-*/
-package api

api/entry.go

@@ -2,222 +2,253 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package api
+package api // import "miniflux.app/api"
 
 import (
+	json_parser "encoding/json"
 	"errors"
+	"net/http"
+	"strconv"
+	"time"
 
-	"github.com/miniflux/miniflux/http/handler"
-	"github.com/miniflux/miniflux/model"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/model"
+	"miniflux.app/reader/processor"
+	"miniflux.app/storage"
+	"miniflux.app/validator"
 )
 
-// GetFeedEntry is the API handler to get a single feed entry.
-func (c *Controller) GetFeedEntry(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	feedID, err := request.IntegerParam("feedID")
+func getEntryFromBuilder(w http.ResponseWriter, r *http.Request, b *storage.EntryQueryBuilder) {
+	entry, err := b.GetEntry()
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	entryID, err := request.IntegerParam("entryID")
-	if err != nil {
-		response.JSON().BadRequest(err)
+	if entry == nil {
+		json.NotFound(w, r)
 		return
 	}
 
-	builder := c.store.NewEntryQueryBuilder(userID)
+	json.OK(w, r, entry)
+}
+
+func (h *handler) getFeedEntry(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
+	entryID := request.RouteInt64Param(r, "entryID")
+
+	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
 	builder.WithFeedID(feedID)
 	builder.WithEntryID(entryID)
 
-	entry, err := builder.GetEntry()
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch this entry from the database"))
-		return
-	}
-
-	if entry == nil {
-		response.JSON().NotFound(errors.New("Entry not found"))
-		return
-	}
-
-	response.JSON().Standard(entry)
+	getEntryFromBuilder(w, r, builder)
 }
 
-// GetEntry is the API handler to get a single entry.
-func (c *Controller) GetEntry(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	entryID, err := request.IntegerParam("entryID")
-	if err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
+func (h *handler) getCategoryEntry(w http.ResponseWriter, r *http.Request) {
+	categoryID := request.RouteInt64Param(r, "categoryID")
+	entryID := request.RouteInt64Param(r, "entryID")
 
-	builder := c.store.NewEntryQueryBuilder(userID)
+	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
+	builder.WithCategoryID(categoryID)
 	builder.WithEntryID(entryID)
 
-	entry, err := builder.GetEntry()
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch this entry from the database"))
-		return
-	}
-
-	if entry == nil {
-		response.JSON().NotFound(errors.New("Entry not found"))
-		return
-	}
-
-	response.JSON().Standard(entry)
+	getEntryFromBuilder(w, r, builder)
 }
 
-// GetFeedEntries is the API handler to get all feed entries.
-func (c *Controller) GetFeedEntries(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	feedID, err := request.IntegerParam("feedID")
-	if err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
+func (h *handler) getEntry(w http.ResponseWriter, r *http.Request) {
+	entryID := request.RouteInt64Param(r, "entryID")
+	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
+	builder.WithEntryID(entryID)
 
-	status := request.QueryStringParam("status", "")
-	if status != "" {
-		if err := model.ValidateEntryStatus(status); err != nil {
-			response.JSON().BadRequest(err)
+	getEntryFromBuilder(w, r, builder)
+}
+
+func (h *handler) getFeedEntries(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
+	h.findEntries(w, r, feedID, 0)
+}
+
+func (h *handler) getCategoryEntries(w http.ResponseWriter, r *http.Request) {
+	categoryID := request.RouteInt64Param(r, "categoryID")
+	h.findEntries(w, r, 0, categoryID)
+}
+
+func (h *handler) getEntries(w http.ResponseWriter, r *http.Request) {
+	h.findEntries(w, r, 0, 0)
+}
+
+func (h *handler) findEntries(w http.ResponseWriter, r *http.Request, feedID int64, categoryID int64) {
+	statuses := request.QueryStringParamList(r, "status")
+	for _, status := range statuses {
+		if err := validator.ValidateEntryStatus(status); err != nil {
+			json.BadRequest(w, r, err)
 			return
 		}
 	}
 
-	order := request.QueryStringParam("order", model.DefaultSortingOrder)
-	if err := model.ValidateEntryOrder(order); err != nil {
-		response.JSON().BadRequest(err)
+	order := request.QueryStringParam(r, "order", model.DefaultSortingOrder)
+	if err := validator.ValidateEntryOrder(order); err != nil {
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	direction := request.QueryStringParam("direction", model.DefaultSortingDirection)
-	if err := model.ValidateDirection(direction); err != nil {
-		response.JSON().BadRequest(err)
+	direction := request.QueryStringParam(r, "direction", model.DefaultSortingDirection)
+	if err := validator.ValidateDirection(direction); err != nil {
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	limit := request.QueryIntegerParam("limit", 100)
-	offset := request.QueryIntegerParam("offset", 0)
-	if err := model.ValidateRange(offset, limit); err != nil {
-		response.JSON().BadRequest(err)
+	limit := request.QueryIntParam(r, "limit", 100)
+	offset := request.QueryIntParam(r, "offset", 0)
+	if err := validator.ValidateRange(offset, limit); err != nil {
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	builder := c.store.NewEntryQueryBuilder(userID)
+	userID := request.UserID(r)
+	categoryID = request.QueryInt64Param(r, "category_id", categoryID)
+	if categoryID > 0 && !h.store.CategoryIDExists(userID, categoryID) {
+		json.BadRequest(w, r, errors.New("Invalid category ID"))
+		return
+	}
+
+	feedID = request.QueryInt64Param(r, "feed_id", feedID)
+	if feedID > 0 && !h.store.FeedExists(userID, feedID) {
+		json.BadRequest(w, r, errors.New("Invalid feed ID"))
+		return
+	}
+
+	builder := h.store.NewEntryQueryBuilder(userID)
 	builder.WithFeedID(feedID)
-	builder.WithStatus(status)
+	builder.WithCategoryID(categoryID)
+	builder.WithStatuses(statuses)
 	builder.WithOrder(order)
 	builder.WithDirection(direction)
 	builder.WithOffset(offset)
 	builder.WithLimit(limit)
+	configureFilters(builder, r)
 
 	entries, err := builder.GetEntries()
 	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch the list of entries"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	count, err := builder.CountEntries()
 	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to count the number of entries"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	response.JSON().Standard(&entriesResponse{Total: count, Entries: entries})
+	json.OK(w, r, &entriesResponse{Total: count, Entries: entries})
 }
 
-// GetEntries is the API handler to fetch entries.
-func (c *Controller) GetEntries(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
+func (h *handler) setEntryStatus(w http.ResponseWriter, r *http.Request) {
+	var entriesStatusUpdateRequest model.EntriesStatusUpdateRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&entriesStatusUpdateRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
 
-	status := request.QueryStringParam("status", "")
-	if status != "" {
-		if err := model.ValidateEntryStatus(status); err != nil {
-			response.JSON().BadRequest(err)
-			return
+	if err := validator.ValidateEntriesStatusUpdateRequest(&entriesStatusUpdateRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
+
+	if err := h.store.SetEntriesStatus(request.UserID(r), entriesStatusUpdateRequest.EntryIDs, entriesStatusUpdateRequest.Status); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.NoContent(w, r)
+}
+
+func (h *handler) toggleBookmark(w http.ResponseWriter, r *http.Request) {
+	entryID := request.RouteInt64Param(r, "entryID")
+	if err := h.store.ToggleBookmark(request.UserID(r), entryID); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.NoContent(w, r)
+}
+
+func (h *handler) fetchContent(w http.ResponseWriter, r *http.Request) {
+	loggedUserID := request.UserID(r)
+	entryID := request.RouteInt64Param(r, "entryID")
+
+	entryBuilder := h.store.NewEntryQueryBuilder(loggedUserID)
+	entryBuilder.WithEntryID(entryID)
+	entryBuilder.WithoutStatus(model.EntryStatusRemoved)
+
+	entry, err := entryBuilder.GetEntry()
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	if entry == nil {
+		json.NotFound(w, r)
+		return
+	}
+
+	feedBuilder := storage.NewFeedQueryBuilder(h.store, loggedUserID)
+	feedBuilder.WithFeedID(entry.FeedID)
+	feed, err := feedBuilder.GetFeed()
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	if feed == nil {
+		json.NotFound(w, r)
+		return
+	}
+
+	if err := processor.ProcessEntryWebPage(feed, entry); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.OK(w, r, map[string]string{"content": entry.Content})
+}
+
+func configureFilters(builder *storage.EntryQueryBuilder, r *http.Request) {
+	beforeEntryID := request.QueryInt64Param(r, "before_entry_id", 0)
+	if beforeEntryID > 0 {
+		builder.BeforeEntryID(beforeEntryID)
+	}
+
+	afterEntryID := request.QueryInt64Param(r, "after_entry_id", 0)
+	if afterEntryID > 0 {
+		builder.AfterEntryID(afterEntryID)
+	}
+
+	beforeTimestamp := request.QueryInt64Param(r, "before", 0)
+	if beforeTimestamp > 0 {
+		builder.BeforeDate(time.Unix(beforeTimestamp, 0))
+	}
+
+	afterTimestamp := request.QueryInt64Param(r, "after", 0)
+	if afterTimestamp > 0 {
+		builder.AfterDate(time.Unix(afterTimestamp, 0))
+	}
+
+	categoryID := request.QueryInt64Param(r, "category_id", 0)
+	if categoryID > 0 {
+		builder.WithCategoryID(categoryID)
+	}
+
+	if request.HasQueryParam(r, "starred") {
+		starred, err := strconv.ParseBool(r.URL.Query().Get("starred"))
+		if err == nil {
+			builder.WithStarred(starred)
 		}
 	}
 
-	order := request.QueryStringParam("order", model.DefaultSortingOrder)
-	if err := model.ValidateEntryOrder(order); err != nil {
-		response.JSON().BadRequest(err)
-		return
+	searchQuery := request.QueryStringParam(r, "search", "")
+	if searchQuery != "" {
+		builder.WithSearchQuery(searchQuery)
 	}
-
-	direction := request.QueryStringParam("direction", model.DefaultSortingDirection)
-	if err := model.ValidateDirection(direction); err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	limit := request.QueryIntegerParam("limit", 100)
-	offset := request.QueryIntegerParam("offset", 0)
-	if err := model.ValidateRange(offset, limit); err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithStatus(status)
-	builder.WithOrder(order)
-	builder.WithDirection(direction)
-	builder.WithOffset(offset)
-	builder.WithLimit(limit)
-
-	entries, err := builder.GetEntries()
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch the list of entries"))
-		return
-	}
-
-	count, err := builder.CountEntries()
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to count the number of entries"))
-		return
-	}
-
-	response.JSON().Standard(&entriesResponse{Total: count, Entries: entries})
-}
-
-// SetEntryStatus is the API handler to change the status of entries.
-func (c *Controller) SetEntryStatus(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-
-	entryIDs, status, err := decodeEntryStatusPayload(request.Body())
-	if err != nil {
-		response.JSON().BadRequest(errors.New("Invalid JSON payload"))
-		return
-	}
-
-	if err := model.ValidateEntryStatus(status); err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	if err := c.store.SetEntriesStatus(userID, entryIDs, status); err != nil {
-		response.JSON().ServerError(errors.New("Unable to change entries status"))
-		return
-	}
-
-	response.JSON().NoContent()
-}
-
-// ToggleBookmark is the API handler to toggle bookmark status.
-func (c *Controller) ToggleBookmark(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	entryID, err := request.IntegerParam("entryID")
-	if err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	if err := c.store.ToggleBookmark(userID, entryID); err != nil {
-		response.JSON().ServerError(errors.New("Unable to toggle bookmark value"))
-		return
-	}
-
-	response.JSON().NoContent()
 }

api/feed.go

@@ -2,191 +2,213 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package api
+package api // import "miniflux.app/api"
 
 import (
-	"errors"
+	json_parser "encoding/json"
+	"net/http"
+	"time"
 
-	"github.com/miniflux/miniflux/reader/opml"
-
-	"github.com/miniflux/miniflux/http/handler"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/model"
+	feedHandler "miniflux.app/reader/handler"
+	"miniflux.app/validator"
 )
 
-// CreateFeed is the API handler to create a new feed.
-func (c *Controller) CreateFeed(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	feedURL, categoryID, err := decodeFeedCreationPayload(request.Body())
+func (h *handler) createFeed(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+
+	var feedCreationRequest model.FeedCreationRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&feedCreationRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
+
+	if validationErr := validator.ValidateFeedCreation(h.store, userID, &feedCreationRequest); validationErr != nil {
+		json.BadRequest(w, r, validationErr.Error())
+		return
+	}
+
+	feed, err := feedHandler.CreateFeed(h.store, userID, &feedCreationRequest)
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	if feedURL == "" {
-		response.JSON().BadRequest(errors.New("The feed_url is required"))
-		return
-	}
-
-	if categoryID <= 0 {
-		response.JSON().BadRequest(errors.New("The category_id is required"))
-		return
-	}
-
-	if c.store.FeedURLExists(userID, feedURL) {
-		response.JSON().BadRequest(errors.New("This feed_url already exists"))
-		return
-	}
-
-	if !c.store.CategoryExists(userID, categoryID) {
-		response.JSON().BadRequest(errors.New("This category_id doesn't exists or doesn't belongs to this user"))
-		return
-	}
-
-	feed, err := c.feedHandler.CreateFeed(userID, categoryID, feedURL, false)
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to create this feed"))
-		return
-	}
-
-	type result struct {
-		FeedID int64 `json:"feed_id"`
-	}
-
-	response.JSON().Created(&result{FeedID: feed.ID})
+	json.Created(w, r, &feedCreationResponse{FeedID: feed.ID})
 }
 
-// RefreshFeed is the API handler to refresh a feed.
-func (c *Controller) RefreshFeed(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	feedID, err := request.IntegerParam("feedID")
+func (h *handler) refreshFeed(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
+	userID := request.UserID(r)
+
+	if !h.store.FeedExists(userID, feedID) {
+		json.NotFound(w, r)
+		return
+	}
+
+	err := feedHandler.RefreshFeed(h.store, userID, feedID)
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	if !c.store.FeedExists(userID, feedID) {
-		response.JSON().NotFound(errors.New("Unable to find this feed"))
-		return
-	}
-
-	err = c.feedHandler.RefreshFeed(userID, feedID)
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to refresh this feed"))
-		return
-	}
-
-	response.JSON().NoContent()
+	json.NoContent(w, r)
 }
 
-// UpdateFeed is the API handler that is used to update a feed.
-func (c *Controller) UpdateFeed(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	feedID, err := request.IntegerParam("feedID")
+func (h *handler) refreshAllFeeds(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	jobs, err := h.store.NewUserBatch(userID, h.store.CountFeeds(userID))
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	newFeed, err := decodeFeedModificationPayload(request.Body())
-	if err != nil {
-		response.JSON().BadRequest(err)
+	go func() {
+		h.pool.Push(jobs)
+	}()
+
+	json.NoContent(w, r)
+}
+
+func (h *handler) updateFeed(w http.ResponseWriter, r *http.Request) {
+	var feedModificationRequest model.FeedModificationRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&feedModificationRequest); err != nil {
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	if newFeed.Category != nil && newFeed.Category.ID != 0 && !c.store.CategoryExists(userID, newFeed.Category.ID) {
-		response.JSON().BadRequest(errors.New("This category_id doesn't exists or doesn't belongs to this user"))
-		return
-	}
+	userID := request.UserID(r)
+	feedID := request.RouteInt64Param(r, "feedID")
 
-	originalFeed, err := c.store.FeedByID(userID, feedID)
+	originalFeed, err := h.store.FeedByID(userID, feedID)
 	if err != nil {
-		response.JSON().NotFound(errors.New("Unable to find this feed"))
+		json.NotFound(w, r)
 		return
 	}
 
 	if originalFeed == nil {
-		response.JSON().NotFound(errors.New("Feed not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	originalFeed.Merge(newFeed)
-	if err := c.store.UpdateFeed(originalFeed); err != nil {
-		response.JSON().ServerError(errors.New("Unable to update this feed"))
+	if validationErr := validator.ValidateFeedModification(h.store, userID, &feedModificationRequest); validationErr != nil {
+		json.BadRequest(w, r, validationErr.Error())
 		return
 	}
 
-	originalFeed, err = c.store.FeedByID(userID, feedID)
+	feedModificationRequest.Patch(originalFeed)
+	if err := h.store.UpdateFeed(originalFeed); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	originalFeed, err = h.store.FeedByID(userID, feedID)
 	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch this feed"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	response.JSON().Created(originalFeed)
+	json.Created(w, r, originalFeed)
 }
 
-// GetFeeds is the API handler that get all feeds that belongs to the given user.
-func (c *Controller) GetFeeds(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	feeds, err := c.store.Feeds(ctx.UserID())
+func (h *handler) markFeedAsRead(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
+	userID := request.UserID(r)
+
+	feed, err := h.store.FeedByID(userID, feedID)
 	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch feeds from the database"))
-		return
-	}
-
-	response.JSON().Standard(feeds)
-}
-
-// Export is the API handler that incoves an OPML export.
-func (c *Controller) Export(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	opmlHandler := opml.NewHandler(c.store)
-
-	opml, err := opmlHandler.Export(ctx.LoggedUser().ID)
-	if err != nil {
-		response.JSON().ServerError(errors.New("unable to export feeds to OPML"))
-	}
-
-	response.XML().Serve(opml)
-}
-
-// GetFeed is the API handler to get a feed.
-func (c *Controller) GetFeed(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	feedID, err := request.IntegerParam("feedID")
-	if err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	feed, err := c.store.FeedByID(userID, feedID)
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch this feed"))
+		json.NotFound(w, r)
 		return
 	}
 
 	if feed == nil {
-		response.JSON().NotFound(errors.New("Feed not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	response.JSON().Standard(feed)
+	if err := h.store.MarkFeedAsRead(userID, feedID, time.Now()); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.NoContent(w, r)
 }
 
-// RemoveFeed is the API handler to remove a feed.
-func (c *Controller) RemoveFeed(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	feedID, err := request.IntegerParam("feedID")
+func (h *handler) getCategoryFeeds(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	categoryID := request.RouteInt64Param(r, "categoryID")
+
+	category, err := h.store.Category(userID, categoryID)
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	if !c.store.FeedExists(userID, feedID) {
-		response.JSON().NotFound(errors.New("Feed not found"))
+	if category == nil {
+		json.NotFound(w, r)
 		return
 	}
 
-	if err := c.store.RemoveFeed(userID, feedID); err != nil {
-		response.JSON().ServerError(errors.New("Unable to remove this feed"))
+	feeds, err := h.store.FeedsByCategoryWithCounters(userID, categoryID)
+	if err != nil {
+		json.ServerError(w, r, err)
 		return
 	}
 
-	response.JSON().NoContent()
+	json.OK(w, r, feeds)
+}
+
+func (h *handler) getFeeds(w http.ResponseWriter, r *http.Request) {
+	feeds, err := h.store.Feeds(request.UserID(r))
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.OK(w, r, feeds)
+}
+
+func (h *handler) fetchCounters(w http.ResponseWriter, r *http.Request) {
+	counters, err := h.store.FetchCounters(request.UserID(r))
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.OK(w, r, counters)
+}
+
+func (h *handler) getFeed(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
+	feed, err := h.store.FeedByID(request.UserID(r), feedID)
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	if feed == nil {
+		json.NotFound(w, r)
+		return
+	}
+
+	json.OK(w, r, feed)
+}
+
+func (h *handler) removeFeed(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
+	userID := request.UserID(r)
+
+	if !h.store.FeedExists(userID, feedID) {
+		json.NotFound(w, r)
+		return
+	}
+
+	if err := h.store.RemoveFeed(userID, feedID); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.NoContent(w, r)
 }

api/icon.go

@@ -2,40 +2,35 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package api
+package api // import "miniflux.app/api"
 
 import (
-	"errors"
+	"net/http"
 
-	"github.com/miniflux/miniflux/http/handler"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
 )
 
-// FeedIcon returns a feed icon.
-func (c *Controller) FeedIcon(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	feedID, err := request.IntegerParam("feedID")
-	if err != nil {
-		response.JSON().BadRequest(err)
+func (h *handler) feedIcon(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
+
+	if !h.store.HasIcon(feedID) {
+		json.NotFound(w, r)
 		return
 	}
 
-	if !c.store.HasIcon(feedID) {
-		response.JSON().NotFound(errors.New("This feed doesn't have any icon"))
-		return
-	}
-
-	icon, err := c.store.IconByFeedID(userID, feedID)
+	icon, err := h.store.IconByFeedID(request.UserID(r), feedID)
 	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch feed icon"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	if icon == nil {
-		response.JSON().NotFound(errors.New("This feed doesn't have any icon"))
+		json.NotFound(w, r)
 		return
 	}
 
-	response.JSON().Standard(&feedIcon{
+	json.OK(w, r, &feedIconResponse{
 		ID:       icon.ID,
 		MimeType: icon.MimeType,
 		Data:     icon.DataURL(),

api/middleware.go

@@ -0,0 +1,129 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package api // import "miniflux.app/api"
+
+import (
+	"context"
+	"net/http"
+
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/logger"
+	"miniflux.app/storage"
+)
+
+type middleware struct {
+	store *storage.Storage
+}
+
+func newMiddleware(s *storage.Storage) *middleware {
+	return &middleware{s}
+}
+func (m *middleware) handleCORS(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "X-Auth-Token")
+		if r.Method == http.MethodOptions {
+			w.Header().Set("Access-Control-Max-Age", "3600")
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		clientIP := request.ClientIP(r)
+		token := r.Header.Get("X-Auth-Token")
+
+		if token == "" {
+			logger.Debug("[API][TokenAuth] [ClientIP=%s] No API Key provided, go to the next middleware", clientIP)
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		user, err := m.store.UserByAPIKey(token)
+		if err != nil {
+			logger.Error("[API][TokenAuth] %v", err)
+			json.ServerError(w, r, err)
+			return
+		}
+
+		if user == nil {
+			logger.Error("[API][TokenAuth] [ClientIP=%s] No user found with the given API key", clientIP)
+			json.Unauthorized(w, r)
+			return
+		}
+
+		logger.Info("[API][TokenAuth] [ClientIP=%s] User authenticated: %s", clientIP, user.Username)
+		m.store.SetLastLogin(user.ID)
+		m.store.SetAPIKeyUsedTimestamp(user.ID, token)
+
+		ctx := r.Context()
+		ctx = context.WithValue(ctx, request.UserIDContextKey, user.ID)
+		ctx = context.WithValue(ctx, request.UserTimezoneContextKey, user.Timezone)
+		ctx = context.WithValue(ctx, request.IsAdminUserContextKey, user.IsAdmin)
+		ctx = context.WithValue(ctx, request.IsAuthenticatedContextKey, true)
+
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func (m *middleware) basicAuth(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if request.IsAuthenticated(r) {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
+
+		clientIP := request.ClientIP(r)
+		username, password, authOK := r.BasicAuth()
+		if !authOK {
+			logger.Debug("[API][BasicAuth] [ClientIP=%s] No authentication headers sent", clientIP)
+			json.Unauthorized(w, r)
+			return
+		}
+
+		if username == "" || password == "" {
+			logger.Error("[API][BasicAuth] [ClientIP=%s] Empty username or password", clientIP)
+			json.Unauthorized(w, r)
+			return
+		}
+
+		if err := m.store.CheckPassword(username, password); err != nil {
+			logger.Error("[API][BasicAuth] [ClientIP=%s] Invalid username or password: %s", clientIP, username)
+			json.Unauthorized(w, r)
+			return
+		}
+
+		user, err := m.store.UserByUsername(username)
+		if err != nil {
+			logger.Error("[API][BasicAuth] %v", err)
+			json.ServerError(w, r, err)
+			return
+		}
+
+		if user == nil {
+			logger.Error("[API][BasicAuth] [ClientIP=%s] User not found: %s", clientIP, username)
+			json.Unauthorized(w, r)
+			return
+		}
+
+		logger.Info("[API][BasicAuth] [ClientIP=%s] User authenticated: %s", clientIP, username)
+		m.store.SetLastLogin(user.ID)
+
+		ctx := r.Context()
+		ctx = context.WithValue(ctx, request.UserIDContextKey, user.ID)
+		ctx = context.WithValue(ctx, request.UserTimezoneContextKey, user.Timezone)
+		ctx = context.WithValue(ctx, request.IsAdminUserContextKey, user.IsAdmin)
+		ctx = context.WithValue(ctx, request.IsAuthenticatedContextKey, true)
+
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

api/opml.go

@@ -0,0 +1,37 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package api // import "miniflux.app/api"
+
+import (
+	"net/http"
+
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/http/response/xml"
+	"miniflux.app/reader/opml"
+)
+
+func (h *handler) exportFeeds(w http.ResponseWriter, r *http.Request) {
+	opmlHandler := opml.NewHandler(h.store)
+	opml, err := opmlHandler.Export(request.UserID(r))
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	xml.OK(w, r, opml)
+}
+
+func (h *handler) importFeeds(w http.ResponseWriter, r *http.Request) {
+	opmlHandler := opml.NewHandler(h.store)
+	err := opmlHandler.Import(request.UserID(r), r.Body)
+	defer r.Body.Close()
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.Created(w, r, map[string]string{"message": "Feeds imported successfully"})
+}

api/payload.go

@@ -2,17 +2,13 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package api
+package api // import "miniflux.app/api"
 
 import (
-	"encoding/json"
-	"fmt"
-	"io"
-
-	"github.com/miniflux/miniflux/model"
+	"miniflux.app/model"
 )
 
-type feedIcon struct {
+type feedIconResponse struct {
 	ID       int64  `json:"id"`
 	MimeType string `json:"mime_type"`
 	Data     string `json:"data"`
@@ -23,79 +19,6 @@ type entriesResponse struct {
 	Entries model.Entries `json:"entries"`
 }
 
-func decodeUserPayload(data io.Reader) (*model.User, error) {
-	var user model.User
-
-	decoder := json.NewDecoder(data)
-	if err := decoder.Decode(&user); err != nil {
-		return nil, fmt.Errorf("Unable to decode user JSON object: %v", err)
-	}
-
-	return &user, nil
-}
-
-func decodeURLPayload(data io.Reader) (string, error) {
-	type payload struct {
-		URL string `json:"url"`
-	}
-
-	var p payload
-	decoder := json.NewDecoder(data)
-	if err := decoder.Decode(&p); err != nil {
-		return "", fmt.Errorf("invalid JSON payload: %v", err)
-	}
-
-	return p.URL, nil
-}
-
-func decodeEntryStatusPayload(data io.Reader) ([]int64, string, error) {
-	type payload struct {
-		EntryIDs []int64 `json:"entry_ids"`
-		Status   string  `json:"status"`
-	}
-
-	var p payload
-	decoder := json.NewDecoder(data)
-	if err := decoder.Decode(&p); err != nil {
-		return nil, "", fmt.Errorf("invalid JSON payload: %v", err)
-	}
-
-	return p.EntryIDs, p.Status, nil
-}
-
-func decodeFeedCreationPayload(data io.Reader) (string, int64, error) {
-	type payload struct {
-		FeedURL    string `json:"feed_url"`
-		CategoryID int64  `json:"category_id"`
-	}
-
-	var p payload
-	decoder := json.NewDecoder(data)
-	if err := decoder.Decode(&p); err != nil {
-		return "", 0, fmt.Errorf("invalid JSON payload: %v", err)
-	}
-
-	return p.FeedURL, p.CategoryID, nil
-}
-
-func decodeFeedModificationPayload(data io.Reader) (*model.Feed, error) {
-	var feed model.Feed
-
-	decoder := json.NewDecoder(data)
-	if err := decoder.Decode(&feed); err != nil {
-		return nil, fmt.Errorf("Unable to decode feed JSON object: %v", err)
-	}
-
-	return &feed, nil
-}
-
-func decodeCategoryPayload(data io.Reader) (*model.Category, error) {
-	var category model.Category
-
-	decoder := json.NewDecoder(data)
-	if err := decoder.Decode(&category); err != nil {
-		return nil, fmt.Errorf("Unable to decode category JSON object: %v", err)
-	}
-
-	return &category, nil
+type feedCreationResponse struct {
+	FeedID int64 `json:"feed_id"`
 }

api/subscription.go

@@ -2,34 +2,48 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package api
+package api // import "miniflux.app/api"
 
 import (
-	"errors"
-	"fmt"
+	json_parser "encoding/json"
+	"net/http"
 
-	"github.com/miniflux/miniflux/http/handler"
-	"github.com/miniflux/miniflux/reader/subscription"
+	"miniflux.app/http/response/json"
+	"miniflux.app/model"
+	"miniflux.app/reader/subscription"
+	"miniflux.app/validator"
 )
 
-// GetSubscriptions is the API handler to find subscriptions.
-func (c *Controller) GetSubscriptions(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	websiteURL, err := decodeURLPayload(request.Body())
-	if err != nil {
-		response.JSON().BadRequest(err)
+func (h *handler) discoverSubscriptions(w http.ResponseWriter, r *http.Request) {
+	var subscriptionDiscoveryRequest model.SubscriptionDiscoveryRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&subscriptionDiscoveryRequest); err != nil {
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	subscriptions, err := subscription.FindSubscriptions(websiteURL)
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to discover subscriptions"))
+	if validationErr := validator.ValidateSubscriptionDiscovery(&subscriptionDiscoveryRequest); validationErr != nil {
+		json.BadRequest(w, r, validationErr.Error())
+		return
+	}
+
+	subscriptions, finderErr := subscription.FindSubscriptions(
+		subscriptionDiscoveryRequest.URL,
+		subscriptionDiscoveryRequest.UserAgent,
+		subscriptionDiscoveryRequest.Cookie,
+		subscriptionDiscoveryRequest.Username,
+		subscriptionDiscoveryRequest.Password,
+		subscriptionDiscoveryRequest.FetchViaProxy,
+		subscriptionDiscoveryRequest.AllowSelfSignedCertificates,
+	)
+	if finderErr != nil {
+		json.ServerError(w, r, finderErr)
 		return
 	}
 
 	if subscriptions == nil {
-		response.JSON().NotFound(fmt.Errorf("No subscription found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	response.JSON().Standard(subscriptions)
+	json.OK(w, r, subscriptions)
 }

api/user.go

@@ -2,184 +2,203 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package api
+package api // import "miniflux.app/api"
 
 import (
+	json_parser "encoding/json"
 	"errors"
+	"net/http"
 
-	"github.com/miniflux/miniflux/http/handler"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/model"
+	"miniflux.app/validator"
 )
 
-// CreateUser is the API handler to create a new user.
-func (c *Controller) CreateUser(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	if !ctx.IsAdminUser() {
-		response.JSON().Forbidden()
-		return
-	}
-
-	user, err := decodeUserPayload(request.Body())
+func (h *handler) currentUser(w http.ResponseWriter, r *http.Request) {
+	user, err := h.store.UserByID(request.UserID(r))
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	if err := user.ValidateUserCreation(); err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	if c.store.UserExists(user.Username) {
-		response.JSON().BadRequest(errors.New("This user already exists"))
-		return
-	}
-
-	err = c.store.CreateUser(user)
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to create this user"))
-		return
-	}
-
-	user.Password = ""
-	response.JSON().Created(user)
+	json.OK(w, r, user)
 }
 
-// UpdateUser is the API handler to update the given user.
-func (c *Controller) UpdateUser(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	if !ctx.IsAdminUser() {
-		response.JSON().Forbidden()
+func (h *handler) createUser(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	userID, err := request.IntegerParam("userID")
+	var userCreationRequest model.UserCreationRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&userCreationRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
+
+	if validationErr := validator.ValidateUserCreationWithPassword(h.store, &userCreationRequest); validationErr != nil {
+		json.BadRequest(w, r, validationErr.Error())
+		return
+	}
+
+	user, err := h.store.CreateUser(&userCreationRequest)
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	user, err := decodeUserPayload(request.Body())
+	json.Created(w, r, user)
+}
+
+func (h *handler) updateUser(w http.ResponseWriter, r *http.Request) {
+	userID := request.RouteInt64Param(r, "userID")
+
+	var userModificationRequest model.UserModificationRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&userModificationRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
+
+	originalUser, err := h.store.UserByID(userID)
 	if err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	if err := user.ValidateUserModification(); err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	originalUser, err := c.store.UserByID(userID)
-	if err != nil {
-		response.JSON().BadRequest(errors.New("Unable to fetch this user from the database"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	if originalUser == nil {
-		response.JSON().NotFound(errors.New("User not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	originalUser.Merge(user)
-	if err = c.store.UpdateUser(originalUser); err != nil {
-		response.JSON().ServerError(errors.New("Unable to update this user"))
+	if !request.IsAdminUser(r) {
+		if originalUser.ID != request.UserID(r) {
+			json.Forbidden(w, r)
+			return
+		}
+
+		if userModificationRequest.IsAdmin != nil && *userModificationRequest.IsAdmin {
+			json.BadRequest(w, r, errors.New("Only administrators can change permissions of standard users"))
+			return
+		}
+	}
+
+	if validationErr := validator.ValidateUserModification(h.store, originalUser.ID, &userModificationRequest); validationErr != nil {
+		json.BadRequest(w, r, validationErr.Error())
 		return
 	}
 
-	response.JSON().Created(originalUser)
+	userModificationRequest.Patch(originalUser)
+	if err = h.store.UpdateUser(originalUser); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.Created(w, r, originalUser)
 }
 
-// Users is the API handler to get the list of users.
-func (c *Controller) Users(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	if !ctx.IsAdminUser() {
-		response.JSON().Forbidden()
+func (h *handler) markUserAsRead(w http.ResponseWriter, r *http.Request) {
+	userID := request.RouteInt64Param(r, "userID")
+	if userID != request.UserID(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	users, err := c.store.Users()
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch the list of users"))
+	if _, err := h.store.UserByID(userID); err != nil {
+		json.NotFound(w, r)
 		return
 	}
 
-	response.JSON().Standard(users)
+	if err := h.store.MarkAllAsRead(userID); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.NoContent(w, r)
 }
 
-// UserByID is the API handler to fetch the given user by the ID.
-func (c *Controller) UserByID(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	if !ctx.IsAdminUser() {
-		response.JSON().Forbidden()
+func (h *handler) users(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	userID, err := request.IntegerParam("userID")
+	users, err := h.store.Users()
 	if err != nil {
-		response.JSON().BadRequest(err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	user, err := c.store.UserByID(userID)
+	users.UseTimezone(request.UserTimezone(r))
+	json.OK(w, r, users)
+}
+
+func (h *handler) userByID(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
+		return
+	}
+
+	userID := request.RouteInt64Param(r, "userID")
+	user, err := h.store.UserByID(userID)
 	if err != nil {
-		response.JSON().BadRequest(errors.New("Unable to fetch this user from the database"))
+		json.BadRequest(w, r, errors.New("Unable to fetch this user from the database"))
 		return
 	}
 
 	if user == nil {
-		response.JSON().NotFound(errors.New("User not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	response.JSON().Standard(user)
+	user.UseTimezone(request.UserTimezone(r))
+	json.OK(w, r, user)
 }
 
-// UserByUsername is the API handler to fetch the given user by the username.
-func (c *Controller) UserByUsername(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	if !ctx.IsAdminUser() {
-		response.JSON().Forbidden()
+func (h *handler) userByUsername(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	username := request.StringParam("username", "")
-	user, err := c.store.UserByUsername(username)
+	username := request.RouteStringParam(r, "username")
+	user, err := h.store.UserByUsername(username)
 	if err != nil {
-		response.JSON().BadRequest(errors.New("Unable to fetch this user from the database"))
+		json.BadRequest(w, r, errors.New("Unable to fetch this user from the database"))
 		return
 	}
 
 	if user == nil {
-		response.JSON().NotFound(errors.New("User not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	response.JSON().Standard(user)
+	json.OK(w, r, user)
 }
 
-// RemoveUser is the API handler to remove an existing user.
-func (c *Controller) RemoveUser(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	if !ctx.IsAdminUser() {
-		response.JSON().Forbidden()
+func (h *handler) removeUser(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	userID, err := request.IntegerParam("userID")
+	userID := request.RouteInt64Param(r, "userID")
+	user, err := h.store.UserByID(userID)
 	if err != nil {
-		response.JSON().BadRequest(err)
-		return
-	}
-
-	user, err := c.store.UserByID(userID)
-	if err != nil {
-		response.JSON().ServerError(errors.New("Unable to fetch this user from the database"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	if user == nil {
-		response.JSON().NotFound(errors.New("User not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	if err := c.store.RemoveUser(user.ID); err != nil {
-		response.JSON().BadRequest(errors.New("Unable to remove this user from the database"))
+	if user.ID == request.UserID(r) {
+		json.BadRequest(w, r, errors.New("You cannot remove yourself"))
 		return
 	}
 
-	response.JSON().NoContent()
+	h.store.RemoveUserAsync(user.ID)
+	json.NoContent(w, r)
 }

cli/ask_credentials.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package cli
+package cli // import "miniflux.app/cli"
 
 import (
 	"bufio"
@@ -14,13 +14,23 @@ import (
 )
 
 func askCredentials() (string, string) {
-	reader := bufio.NewReader(os.Stdin)
+	fd := int(os.Stdin.Fd())
+
+	if !terminal.IsTerminal(fd) {
+		fmt.Fprintf(os.Stderr, "This is not a terminal, exiting.\n")
+		os.Exit(1)
+	}
 
 	fmt.Print("Enter Username: ")
+
+	reader := bufio.NewReader(os.Stdin)
 	username, _ := reader.ReadString('\n')
 
 	fmt.Print("Enter Password: ")
-	bytePassword, _ := terminal.ReadPassword(0)
+
+	state, _ := terminal.GetState(fd)
+	defer terminal.Restore(fd, state)
+	bytePassword, _ := terminal.ReadPassword(fd)
 
 	fmt.Printf("\n")
 	return strings.TrimSpace(username), strings.TrimSpace(string(bytePassword))

cli/cli.go

@@ -2,70 +2,191 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package cli
+package cli // import "miniflux.app/cli"
 
 import (
 	"flag"
 	"fmt"
 
-	"github.com/miniflux/miniflux/logger"
+	"miniflux.app/config"
+	"miniflux.app/database"
+	"miniflux.app/locale"
+	"miniflux.app/logger"
+	"miniflux.app/storage"
+	"miniflux.app/ui/static"
+	"miniflux.app/version"
+)
 
-	"github.com/miniflux/miniflux/config"
-	"github.com/miniflux/miniflux/daemon"
-	"github.com/miniflux/miniflux/storage"
-	"github.com/miniflux/miniflux/version"
+const (
+	flagInfoHelp            = "Show application information"
+	flagVersionHelp         = "Show application version"
+	flagMigrateHelp         = "Run SQL migrations"
+	flagFlushSessionsHelp   = "Flush all sessions (disconnect users)"
+	flagCreateAdminHelp     = "Create admin user"
+	flagResetPasswordHelp   = "Reset user password"
+	flagResetFeedErrorsHelp = "Clear all feed errors for all users"
+	flagDebugModeHelp       = "Show debug logs"
+	flagConfigFileHelp      = "Load configuration file"
+	flagConfigDumpHelp      = "Print parsed configuration values"
+	flagHealthCheckHelp     = `Perform a health check on the given endpoint (the value "auto" try to guess the health check endpoint).`
 )
 
 // Parse parses command line arguments.
 func Parse() {
-	flagInfo := flag.Bool("info", false, "Show application information")
-	flagVersion := flag.Bool("version", false, "Show application version")
-	flagMigrate := flag.Bool("migrate", false, "Migrate database schema")
-	flagFlushSessions := flag.Bool("flush-sessions", false, "Flush all sessions (disconnect users)")
-	flagCreateAdmin := flag.Bool("create-admin", false, "Create admin user")
-	flagResetPassword := flag.Bool("reset-password", false, "Reset user password")
-	flagDebugMode := flag.Bool("debug", false, "Enable debug mode (more verbose output)")
-	flag.Parse()
-
-	cfg := config.NewConfig()
-	store := storage.NewStorage(
-		cfg.DatabaseURL(),
-		cfg.DatabaseMaxConnections(),
+	var (
+		err                 error
+		flagInfo            bool
+		flagVersion         bool
+		flagMigrate         bool
+		flagFlushSessions   bool
+		flagCreateAdmin     bool
+		flagResetPassword   bool
+		flagResetFeedErrors bool
+		flagDebugMode       bool
+		flagConfigFile      string
+		flagConfigDump      bool
+		flagHealthCheck     string
 	)
 
-	if *flagInfo {
+	flag.BoolVar(&flagInfo, "info", false, flagInfoHelp)
+	flag.BoolVar(&flagInfo, "i", false, flagInfoHelp)
+	flag.BoolVar(&flagVersion, "version", false, flagVersionHelp)
+	flag.BoolVar(&flagVersion, "v", false, flagVersionHelp)
+	flag.BoolVar(&flagMigrate, "migrate", false, flagMigrateHelp)
+	flag.BoolVar(&flagFlushSessions, "flush-sessions", false, flagFlushSessionsHelp)
+	flag.BoolVar(&flagCreateAdmin, "create-admin", false, flagCreateAdminHelp)
+	flag.BoolVar(&flagResetPassword, "reset-password", false, flagResetPasswordHelp)
+	flag.BoolVar(&flagResetFeedErrors, "reset-feed-errors", false, flagResetFeedErrorsHelp)
+	flag.BoolVar(&flagDebugMode, "debug", false, flagDebugModeHelp)
+	flag.StringVar(&flagConfigFile, "config-file", "", flagConfigFileHelp)
+	flag.StringVar(&flagConfigFile, "c", "", flagConfigFileHelp)
+	flag.BoolVar(&flagConfigDump, "config-dump", false, flagConfigDumpHelp)
+	flag.StringVar(&flagHealthCheck, "healthcheck", "", flagHealthCheckHelp)
+	flag.Parse()
+
+	cfg := config.NewParser()
+
+	if flagConfigFile != "" {
+		config.Opts, err = cfg.ParseFile(flagConfigFile)
+		if err != nil {
+			logger.Fatal("%v", err)
+		}
+	}
+
+	config.Opts, err = cfg.ParseEnvironmentVariables()
+	if err != nil {
+		logger.Fatal("%v", err)
+	}
+
+	if flagConfigDump {
+		fmt.Print(config.Opts)
+		return
+	}
+
+	if config.Opts.LogDateTime() {
+		logger.EnableDateTime()
+	}
+
+	if flagDebugMode || config.Opts.HasDebugMode() {
+		logger.EnableDebug()
+	}
+
+	if flagHealthCheck != "" {
+		doHealthCheck(flagHealthCheck)
+		return
+	}
+
+	if flagInfo {
 		info()
 		return
 	}
 
-	if *flagVersion {
+	if flagVersion {
 		fmt.Println(version.Version)
 		return
 	}
 
-	if *flagMigrate {
-		store.Migrate()
+	if config.Opts.IsDefaultDatabaseURL() {
+		logger.Info("The default value for DATABASE_URL is used")
+	}
+
+	logger.Debug("Loading translations...")
+	if err := locale.LoadCatalogMessages(); err != nil {
+		logger.Fatal("Unable to load translations: %v", err)
+	}
+
+	logger.Debug("Loading static assets...")
+	if err := static.CalculateBinaryFileChecksums(); err != nil {
+		logger.Fatal("Unable to calculate binary files checksum: %v", err)
+	}
+
+	if err := static.GenerateStylesheetsBundles(); err != nil {
+		logger.Fatal("Unable to generate Stylesheet bundles: %v", err)
+	}
+
+	if err := static.GenerateJavascriptBundles(); err != nil {
+		logger.Fatal("Unable to generate Javascript bundles: %v", err)
+	}
+
+	db, err := database.NewConnectionPool(
+		config.Opts.DatabaseURL(),
+		config.Opts.DatabaseMinConns(),
+		config.Opts.DatabaseMaxConns(),
+		config.Opts.DatabaseConnectionLifetime(),
+	)
+	if err != nil {
+		logger.Fatal("Unable to initialize database connection pool: %v", err)
+	}
+	defer db.Close()
+
+	store := storage.NewStorage(db)
+
+	if err := store.Ping(); err != nil {
+		logger.Fatal("Unable to connect to the database: %v", err)
+	}
+
+	if flagMigrate {
+		if err := database.Migrate(db); err != nil {
+			logger.Fatal(`%v`, err)
+		}
 		return
 	}
 
-	if *flagFlushSessions {
+	if flagResetFeedErrors {
+		store.ResetFeedErrors()
+		return
+	}
+
+	if flagFlushSessions {
 		flushSessions(store)
 		return
 	}
 
-	if *flagCreateAdmin {
+	if flagCreateAdmin {
 		createAdmin(store)
 		return
 	}
 
-	if *flagResetPassword {
+	if flagResetPassword {
 		resetPassword(store)
 		return
 	}
 
-	if *flagDebugMode || cfg.HasDebugMode() {
-		logger.EnableDebug()
+	// Run migrations and start the daemon.
+	if config.Opts.RunMigrations() {
+		if err := database.Migrate(db); err != nil {
+			logger.Fatal(`%v`, err)
+		}
 	}
 
-	daemon.Run(cfg, store)
+	if err := database.IsSchemaUpToDate(db); err != nil {
+		logger.Fatal(`You must run the SQL migrations, %v`, err)
+	}
+
+	// Create admin user and start the daemon.
+	if config.Opts.CreateAdmin() {
+		createAdmin(store)
+	}
+
+	startDaemon(store)
 }

cli/create_admin.go

@@ -2,33 +2,42 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package cli
+package cli // import "miniflux.app/cli"
 
 import (
 	"fmt"
 	"os"
 
-	"github.com/miniflux/miniflux/model"
-	"github.com/miniflux/miniflux/storage"
+	"miniflux.app/config"
+	"miniflux.app/logger"
+	"miniflux.app/model"
+	"miniflux.app/storage"
+	"miniflux.app/validator"
 )
 
 func createAdmin(store *storage.Storage) {
-	user := model.NewUser()
-	user.Username = os.Getenv("ADMIN_USERNAME")
-	user.Password = os.Getenv("ADMIN_PASSWORD")
-	user.IsAdmin = true
-
-	if user.Username == "" || user.Password == "" {
-		user.Username, user.Password = askCredentials()
+	userCreationRequest := &model.UserCreationRequest{
+		Username: config.Opts.AdminUsername(),
+		Password: config.Opts.AdminPassword(),
+		IsAdmin:  true,
 	}
 
-	if err := user.ValidateUserCreation(); err != nil {
-		fmt.Println(err)
+	if userCreationRequest.Username == "" || userCreationRequest.Password == "" {
+		userCreationRequest.Username, userCreationRequest.Password = askCredentials()
+	}
+
+	if store.UserExists(userCreationRequest.Username) {
+		logger.Info(`User %q already exists, skipping creation`, userCreationRequest.Username)
+		return
+	}
+
+	if validationErr := validator.ValidateUserCreationWithPassword(store, userCreationRequest); validationErr != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", validationErr)
 		os.Exit(1)
 	}
 
-	if err := store.CreateUser(user); err != nil {
-		fmt.Println(err)
+	if _, err := store.CreateUser(userCreationRequest); err != nil {
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 }

cli/daemon.go

@@ -0,0 +1,89 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package cli // import "miniflux.app/cli"
+
+import (
+	"context"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"miniflux.app/config"
+	"miniflux.app/logger"
+	"miniflux.app/metric"
+	"miniflux.app/service/httpd"
+	"miniflux.app/service/scheduler"
+	"miniflux.app/storage"
+	"miniflux.app/systemd"
+	"miniflux.app/worker"
+)
+
+func startDaemon(store *storage.Storage) {
+	logger.Info("Starting Miniflux...")
+
+	stop := make(chan os.Signal, 1)
+	signal.Notify(stop, os.Interrupt)
+	signal.Notify(stop, syscall.SIGTERM)
+
+	pool := worker.NewPool(store, config.Opts.WorkerPoolSize())
+
+	if config.Opts.HasSchedulerService() && !config.Opts.HasMaintenanceMode() {
+		scheduler.Serve(store, pool)
+	}
+
+	var httpServer *http.Server
+	if config.Opts.HasHTTPService() {
+		httpServer = httpd.Serve(store, pool)
+	}
+
+	if config.Opts.HasMetricsCollector() {
+		collector := metric.NewCollector(store, config.Opts.MetricsRefreshInterval())
+		go collector.GatherStorageMetrics()
+	}
+
+	if systemd.HasNotifySocket() {
+		logger.Info("Sending readiness notification to Systemd")
+
+		if err := systemd.SdNotify(systemd.SdNotifyReady); err != nil {
+			logger.Error("Unable to send readiness notification to systemd: %v", err)
+		}
+
+		if config.Opts.HasWatchdog() && systemd.HasSystemdWatchdog() {
+			logger.Info("Activating Systemd watchdog")
+
+			go func() {
+				interval, err := systemd.WatchdogInterval()
+				if err != nil {
+					logger.Error("Unable to parse watchdog interval from systemd: %v", err)
+					return
+				}
+
+				for {
+					err := store.Ping()
+					if err != nil {
+						logger.Error(`Systemd Watchdog: %v`, err)
+					} else {
+						systemd.SdNotify(systemd.SdNotifyWatchdog)
+					}
+
+					time.Sleep(interval / 3)
+				}
+			}()
+		}
+	}
+
+	<-stop
+	logger.Info("Shutting down the process...")
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	if httpServer != nil {
+		httpServer.Shutdown(ctx)
+	}
+
+	logger.Info("Process gracefully stopped")
+}

cli/doc.go

@@ -1,10 +1,10 @@
 // Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
 
 /*
 
 Package cli implements command line arguments for Miniflux application.
 
 */
-package cli
+package cli // import "miniflux.app/cli"

cli/flush_sessions.go

@@ -2,19 +2,19 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package cli
+package cli // import "miniflux.app/cli"
 
 import (
 	"fmt"
 	"os"
 
-	"github.com/miniflux/miniflux/storage"
+	"miniflux.app/storage"
 )
 
 func flushSessions(store *storage.Storage) {
 	fmt.Println("Flushing all sessions (disconnect users)")
 	if err := store.FlushAllSessions(); err != nil {
-		fmt.Println(err)
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 }

cli/health_check.go

@@ -0,0 +1,34 @@
+// Copyright 2021 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package cli // import "miniflux.app/cli"
+
+import (
+	"net/http"
+	"time"
+
+	"miniflux.app/config"
+	"miniflux.app/logger"
+)
+
+func doHealthCheck(healthCheckEndpoint string) {
+	if healthCheckEndpoint == "auto" {
+		healthCheckEndpoint = "http://" + config.Opts.ListenAddr() + config.Opts.BasePath() + "/healthcheck"
+	}
+
+	logger.Debug(`Executing health check on %s`, healthCheckEndpoint)
+
+	client := &http.Client{Timeout: 3 * time.Second}
+	resp, err := client.Get(healthCheckEndpoint)
+	if err != nil {
+		logger.Fatal(`Health check failure: %v`, err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		logger.Fatal(`Health check failed with status code %d`, resp.StatusCode)
+	}
+
+	logger.Debug(`Health check is OK`)
+}

cli/info.go

@@ -2,17 +2,21 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package cli
+package cli // import "miniflux.app/cli"
 
 import (
 	"fmt"
 	"runtime"
 
-	"github.com/miniflux/miniflux/version"
+	"miniflux.app/version"
 )
 
 func info() {
 	fmt.Println("Version:", version.Version)
+	fmt.Println("Commit:", version.Commit)
 	fmt.Println("Build Date:", version.BuildDate)
 	fmt.Println("Go Version:", runtime.Version())
+	fmt.Println("Compiler:", runtime.Compiler)
+	fmt.Println("Arch:", runtime.GOARCH)
+	fmt.Println("OS:", runtime.GOOS)
 }

cli/reset_password.go

@@ -2,36 +2,41 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package cli
+package cli // import "miniflux.app/cli"
 
 import (
 	"fmt"
 	"os"
 
-	"github.com/miniflux/miniflux/storage"
+	"miniflux.app/model"
+	"miniflux.app/storage"
+	"miniflux.app/validator"
 )
 
 func resetPassword(store *storage.Storage) {
 	username, password := askCredentials()
 	user, err := store.UserByUsername(username)
 	if err != nil {
-		fmt.Println(err)
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 
 	if user == nil {
-		fmt.Println("User not found!")
+		fmt.Fprintf(os.Stderr, "User not found!\n")
+		os.Exit(1)
+	}
+
+	userModificationRequest := &model.UserModificationRequest{
+		Password: &password,
+	}
+	if validationErr := validator.ValidateUserModification(store, user.ID, userModificationRequest); validationErr != nil {
+		fmt.Fprintf(os.Stderr, "%s\n", validationErr)
 		os.Exit(1)
 	}
 
 	user.Password = password
-	if err := user.ValidatePassword(); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
 	if err := store.UpdateUser(user); err != nil {
-		fmt.Println(err)
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 

client/README.md

@@ -0,0 +1,56 @@
+Miniflux API Client
+===================
+
+[![PkgGoDev](https://pkg.go.dev/badge/miniflux.app/client)](https://pkg.go.dev/miniflux.app/client)
+
+Client library for Miniflux REST API.
+
+Installation
+------------
+
+```bash
+go get -u miniflux.app/client
+```
+
+Example
+-------
+
+```go
+package main
+
+import (
+	"fmt"
+	"os"
+
+	miniflux "miniflux.app/client"
+)
+
+func main() {
+    // Authentication with username/password:
+    client := miniflux.New("https://api.example.org", "admin", "secret")
+
+    // Authentication with an API Key:
+    client := miniflux.New("https://api.example.org", "my-secret-token")
+
+    // Fetch all feeds.
+    feeds, err := client.Feeds()
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    fmt.Println(feeds)
+
+    // Backup your feeds to an OPML file.
+    opml, err := client.Export()
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+
+    err = os.WriteFile("opml.xml", opml, 0644)
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+}
+```

client/client.go

@@ -1,22 +1,47 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
 
-package miniflux
+package client // import "miniflux.app/client"
 
 import (
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/url"
 	"strconv"
 )
 
-// Client represents a Miniflux client.
+// Client holds API procedure calls.
 type Client struct {
 	request *request
 }
 
+// New returns a new Miniflux client.
+func New(endpoint string, credentials ...string) *Client {
+	if len(credentials) == 2 {
+		return &Client{request: &request{endpoint: endpoint, username: credentials[0], password: credentials[1]}}
+	}
+	return &Client{request: &request{endpoint: endpoint, apiKey: credentials[0]}}
+}
+
+// Me returns the logged user information.
+func (c *Client) Me() (*User, error) {
+	body, err := c.request.Get("/v1/me")
+	if err != nil {
+		return nil, err
+	}
+	defer body.Close()
+
+	var user *User
+	decoder := json.NewDecoder(body)
+	if err := decoder.Decode(&user); err != nil {
+		return nil, fmt.Errorf("miniflux: json error (%v)", err)
+	}
+
+	return user, nil
+}
+
 // Users returns all users.
 func (c *Client) Users() (Users, error) {
 	body, err := c.request.Get("/v1/users")
@@ -70,7 +95,11 @@ func (c *Client) UserByUsername(username string) (*User, error) {
 
 // CreateUser creates a new user in the system.
 func (c *Client) CreateUser(username, password string, isAdmin bool) (*User, error) {
-	body, err := c.request.Post("/v1/users", &User{Username: username, Password: password, IsAdmin: isAdmin})
+	body, err := c.request.Post("/v1/users", &UserCreationRequest{
+		Username: username,
+		Password: password,
+		IsAdmin:  isAdmin,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -86,8 +115,8 @@ func (c *Client) CreateUser(username, password string, isAdmin bool) (*User, err
 }
 
 // UpdateUser updates a user in the system.
-func (c *Client) UpdateUser(user *User) (*User, error) {
-	body, err := c.request.Put(fmt.Sprintf("/v1/users/%d", user.ID), user)
+func (c *Client) UpdateUser(userID int64, userChanges *UserModificationRequest) (*User, error) {
+	body, err := c.request.Put(fmt.Sprintf("/v1/users/%d", userID), userChanges)
 	if err != nil {
 		return nil, err
 	}
@@ -104,12 +133,13 @@ func (c *Client) UpdateUser(user *User) (*User, error) {
 
 // DeleteUser removes a user from the system.
 func (c *Client) DeleteUser(userID int64) error {
-	body, err := c.request.Delete(fmt.Sprintf("/v1/users/%d", userID))
-	if err != nil {
-		return err
-	}
-	body.Close()
-	return nil
+	return c.request.Delete(fmt.Sprintf("/v1/users/%d", userID))
+}
+
+// MarkAllAsRead marks all unread entries as read for a given user.
+func (c *Client) MarkAllAsRead(userID int64) error {
+	_, err := c.request.Put(fmt.Sprintf("/v1/users/%d/mark-all-as-read", userID), nil)
+	return err
 }
 
 // Discover try to find subscriptions from a website.
@@ -186,15 +216,32 @@ func (c *Client) UpdateCategory(categoryID int64, title string) (*Category, erro
 	return category, nil
 }
 
-// DeleteCategory removes a category.
-func (c *Client) DeleteCategory(categoryID int64) error {
-	body, err := c.request.Delete(fmt.Sprintf("/v1/categories/%d", categoryID))
+// MarkCategoryAsRead marks all unread entries in a category as read.
+func (c *Client) MarkCategoryAsRead(categoryID int64) error {
+	_, err := c.request.Put(fmt.Sprintf("/v1/categories/%d/mark-all-as-read", categoryID), nil)
+	return err
+}
+
+// CategoryFeeds gets feeds of a category.
+func (c *Client) CategoryFeeds(categoryID int64) (Feeds, error) {
+	body, err := c.request.Get(fmt.Sprintf("/v1/categories/%d/feeds", categoryID))
 	if err != nil {
-		return err
+		return nil, err
 	}
 	defer body.Close()
 
-	return nil
+	var feeds Feeds
+	decoder := json.NewDecoder(body)
+	if err := decoder.Decode(&feeds); err != nil {
+		return nil, fmt.Errorf("miniflux: response error (%v)", err)
+	}
+
+	return feeds, nil
+}
+
+// DeleteCategory removes a category.
+func (c *Client) DeleteCategory(categoryID int64) error {
+	return c.request.Delete(fmt.Sprintf("/v1/categories/%d", categoryID))
 }
 
 // Feeds gets all feeds.
@@ -222,7 +269,7 @@ func (c *Client) Export() ([]byte, error) {
 	}
 	defer body.Close()
 
-	opml, err := ioutil.ReadAll(body)
+	opml, err := io.ReadAll(body)
 	if err != nil {
 		return nil, err
 	}
@@ -230,6 +277,12 @@ func (c *Client) Export() ([]byte, error) {
 	return opml, nil
 }
 
+// Import imports an OPML file.
+func (c *Client) Import(f io.ReadCloser) error {
+	_, err := c.request.PostFile("/v1/import", f)
+	return err
+}
+
 // Feed gets a feed.
 func (c *Client) Feed(feedID int64) (*Feed, error) {
 	body, err := c.request.Get(fmt.Sprintf("/v1/feeds/%d", feedID))
@@ -248,11 +301,8 @@ func (c *Client) Feed(feedID int64) (*Feed, error) {
 }
 
 // CreateFeed creates a new feed.
-func (c *Client) CreateFeed(url string, categoryID int64) (int64, error) {
-	body, err := c.request.Post("/v1/feeds", map[string]interface{}{
-		"feed_url":    url,
-		"category_id": categoryID,
-	})
+func (c *Client) CreateFeed(feedCreationRequest *FeedCreationRequest) (int64, error) {
+	body, err := c.request.Post("/v1/feeds", feedCreationRequest)
 	if err != nil {
 		return 0, err
 	}
@@ -272,40 +322,42 @@ func (c *Client) CreateFeed(url string, categoryID int64) (int64, error) {
 }
 
 // UpdateFeed updates a feed.
-func (c *Client) UpdateFeed(feed *Feed) (*Feed, error) {
-	body, err := c.request.Put(fmt.Sprintf("/v1/feeds/%d", feed.ID), feed)
+func (c *Client) UpdateFeed(feedID int64, feedChanges *FeedModificationRequest) (*Feed, error) {
+	body, err := c.request.Put(fmt.Sprintf("/v1/feeds/%d", feedID), feedChanges)
 	if err != nil {
 		return nil, err
 	}
 	defer body.Close()
 
 	var f *Feed
-	decoder := json.NewDecoder(body)
-	if err := decoder.Decode(&f); err != nil {
+	if err := json.NewDecoder(body).Decode(&f); err != nil {
 		return nil, fmt.Errorf("miniflux: response error (%v)", err)
 	}
 
 	return f, nil
 }
 
-// RefreshFeed refresh a feed.
+// MarkFeedAsRead marks all unread entries of the feed as read.
+func (c *Client) MarkFeedAsRead(feedID int64) error {
+	_, err := c.request.Put(fmt.Sprintf("/v1/feeds/%d/mark-all-as-read", feedID), nil)
+	return err
+}
+
+// RefreshAllFeeds refreshes all feeds.
+func (c *Client) RefreshAllFeeds() error {
+	_, err := c.request.Put("/v1/feeds/refresh", nil)
+	return err
+}
+
+// RefreshFeed refreshes a feed.
 func (c *Client) RefreshFeed(feedID int64) error {
-	body, err := c.request.Put(fmt.Sprintf("/v1/feeds/%d/refresh", feedID), nil)
-	if err != nil {
-		return err
-	}
-	body.Close()
-	return nil
+	_, err := c.request.Put(fmt.Sprintf("/v1/feeds/%d/refresh", feedID), nil)
+	return err
 }
 
 // DeleteFeed removes a feed.
 func (c *Client) DeleteFeed(feedID int64) error {
-	body, err := c.request.Delete(fmt.Sprintf("/v1/feeds/%d", feedID))
-	if err != nil {
-		return err
-	}
-	body.Close()
-	return nil
+	return c.request.Delete(fmt.Sprintf("/v1/feeds/%d", feedID))
 }
 
 // FeedIcon gets a feed icon.
@@ -342,6 +394,23 @@ func (c *Client) FeedEntry(feedID, entryID int64) (*Entry, error) {
 	return entry, nil
 }
 
+// CategoryEntry gets a single category entry.
+func (c *Client) CategoryEntry(categoryID, entryID int64) (*Entry, error) {
+	body, err := c.request.Get(fmt.Sprintf("/v1/categories/%d/entries/%d", categoryID, entryID))
+	if err != nil {
+		return nil, err
+	}
+	defer body.Close()
+
+	var entry *Entry
+	decoder := json.NewDecoder(body)
+	if err := decoder.Decode(&entry); err != nil {
+		return nil, fmt.Errorf("miniflux: response error (%v)", err)
+	}
+
+	return entry, nil
+}
+
 // Entry gets a single entry.
 func (c *Client) Entry(entryID int64) (*Entry, error) {
 	body, err := c.request.Get(fmt.Sprintf("/v1/entries/%d", entryID))
@@ -397,6 +466,25 @@ func (c *Client) FeedEntries(feedID int64, filter *Filter) (*EntryResultSet, err
 	return &result, nil
 }
 
+// CategoryEntries fetch entries of a category.
+func (c *Client) CategoryEntries(categoryID int64, filter *Filter) (*EntryResultSet, error) {
+	path := buildFilterQueryString(fmt.Sprintf("/v1/categories/%d/entries", categoryID), filter)
+
+	body, err := c.request.Get(path)
+	if err != nil {
+		return nil, err
+	}
+	defer body.Close()
+
+	var result EntryResultSet
+	decoder := json.NewDecoder(body)
+	if err := decoder.Decode(&result); err != nil {
+		return nil, fmt.Errorf("miniflux: response error (%v)", err)
+	}
+
+	return &result, nil
+}
+
 // UpdateEntries updates the status of a list of entries.
 func (c *Client) UpdateEntries(entryIDs []int64, status string) error {
 	type payload struct {
@@ -404,29 +492,31 @@ func (c *Client) UpdateEntries(entryIDs []int64, status string) error {
 		Status   string  `json:"status"`
 	}
 
-	body, err := c.request.Put("/v1/entries", &payload{EntryIDs: entryIDs, Status: status})
-	if err != nil {
-		return err
-	}
-	body.Close()
-
-	return nil
+	_, err := c.request.Put("/v1/entries", &payload{EntryIDs: entryIDs, Status: status})
+	return err
 }
 
 // ToggleBookmark toggles entry bookmark value.
 func (c *Client) ToggleBookmark(entryID int64) error {
-	body, err := c.request.Put(fmt.Sprintf("/v1/entries/%d/bookmark", entryID), nil)
-	if err != nil {
-		return err
-	}
-	body.Close()
-
-	return nil
+	_, err := c.request.Put(fmt.Sprintf("/v1/entries/%d/bookmark", entryID), nil)
+	return err
 }
 
-// NewClient returns a new Client.
-func NewClient(endpoint, username, password string) *Client {
-	return &Client{request: &request{endpoint: endpoint, username: username, password: password}}
+// FetchCounters
+func (c *Client) FetchCounters() (*FeedCounters, error) {
+	body, err := c.request.Get("/v1/feeds/counters")
+	if err != nil {
+		return nil, err
+	}
+	defer body.Close()
+
+	var result FeedCounters
+	decoder := json.NewDecoder(body)
+	if err := decoder.Decode(&result); err != nil {
+		return nil, fmt.Errorf("miniflux: response error (%v)", err)
+	}
+
+	return &result, nil
 }
 
 func buildFilterQueryString(path string, filter *Filter) string {
@@ -453,6 +543,42 @@ func buildFilterQueryString(path string, filter *Filter) string {
 			values.Set("offset", strconv.Itoa(filter.Offset))
 		}
 
+		if filter.After > 0 {
+			values.Set("after", strconv.FormatInt(filter.After, 10))
+		}
+
+		if filter.AfterEntryID > 0 {
+			values.Set("after_entry_id", strconv.FormatInt(filter.AfterEntryID, 10))
+		}
+
+		if filter.Before > 0 {
+			values.Set("before", strconv.FormatInt(filter.Before, 10))
+		}
+
+		if filter.BeforeEntryID > 0 {
+			values.Set("before_entry_id", strconv.FormatInt(filter.BeforeEntryID, 10))
+		}
+
+		if filter.Starred != "" {
+			values.Set("starred", filter.Starred)
+		}
+
+		if filter.Search != "" {
+			values.Set("search", filter.Search)
+		}
+
+		if filter.CategoryID > 0 {
+			values.Set("category_id", strconv.FormatInt(filter.CategoryID, 10))
+		}
+
+		if filter.FeedID > 0 {
+			values.Set("feed_id", strconv.FormatInt(filter.FeedID, 10))
+		}
+
+		for _, status := range filter.Statuses {
+			values.Add("status", status)
+		}
+
 		path = fmt.Sprintf("%s?%s", path, values.Encode())
 	}
 

client/doc.go

@@ -0,0 +1,35 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+/*
+
+Package client implements a client library for the Miniflux REST API.
+
+Examples
+
+This code snippet fetch the list of users:
+
+	import (
+		miniflux "miniflux.app/client"
+	)
+
+	client := miniflux.New("https://api.example.org", "admin", "secret")
+	users, err := client.Users()
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println(users, err)
+
+This one discover subscriptions on a website:
+
+	subscriptions, err := client.Discover("https://example.org/")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	fmt.Println(subscriptions)
+
+*/
+package client // import "miniflux.app/client"

client/model.go

@@ -0,0 +1,256 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package client // import "miniflux.app/client"
+
+import (
+	"fmt"
+	"time"
+)
+
+// Entry statuses.
+const (
+	EntryStatusUnread  = "unread"
+	EntryStatusRead    = "read"
+	EntryStatusRemoved = "removed"
+)
+
+// User represents a user in the system.
+type User struct {
+	ID                int64      `json:"id"`
+	Username          string     `json:"username"`
+	Password          string     `json:"password,omitempty"`
+	IsAdmin           bool       `json:"is_admin"`
+	Theme             string     `json:"theme"`
+	Language          string     `json:"language"`
+	Timezone          string     `json:"timezone"`
+	EntryDirection    string     `json:"entry_sorting_direction"`
+	EntryOrder        string     `json:"entry_sorting_order"`
+	Stylesheet        string     `json:"stylesheet"`
+	GoogleID          string     `json:"google_id"`
+	OpenIDConnectID   string     `json:"openid_connect_id"`
+	EntriesPerPage    int        `json:"entries_per_page"`
+	KeyboardShortcuts bool       `json:"keyboard_shortcuts"`
+	ShowReadingTime   bool       `json:"show_reading_time"`
+	EntrySwipe        bool       `json:"entry_swipe"`
+	LastLoginAt       *time.Time `json:"last_login_at"`
+	DisplayMode       string     `json:"display_mode"`
+}
+
+func (u User) String() string {
+	return fmt.Sprintf("#%d - %s (admin=%v)", u.ID, u.Username, u.IsAdmin)
+}
+
+// UserCreationRequest represents the request to create a user.
+type UserCreationRequest struct {
+	Username        string `json:"username"`
+	Password        string `json:"password"`
+	IsAdmin         bool   `json:"is_admin"`
+	GoogleID        string `json:"google_id"`
+	OpenIDConnectID string `json:"openid_connect_id"`
+}
+
+// UserModificationRequest represents the request to update a user.
+type UserModificationRequest struct {
+	Username          *string `json:"username"`
+	Password          *string `json:"password"`
+	IsAdmin           *bool   `json:"is_admin"`
+	Theme             *string `json:"theme"`
+	Language          *string `json:"language"`
+	Timezone          *string `json:"timezone"`
+	EntryDirection    *string `json:"entry_sorting_direction"`
+	EntryOrder        *string `json:"entry_sorting_order"`
+	Stylesheet        *string `json:"stylesheet"`
+	GoogleID          *string `json:"google_id"`
+	OpenIDConnectID   *string `json:"openid_connect_id"`
+	EntriesPerPage    *int    `json:"entries_per_page"`
+	KeyboardShortcuts *bool   `json:"keyboard_shortcuts"`
+	ShowReadingTime   *bool   `json:"show_reading_time"`
+	EntrySwipe        *bool   `json:"entry_swipe"`
+	DisplayMode       *string `json:"display_mode"`
+}
+
+// Users represents a list of users.
+type Users []User
+
+// Category represents a feed category.
+type Category struct {
+	ID     int64  `json:"id,omitempty"`
+	Title  string `json:"title,omitempty"`
+	UserID int64  `json:"user_id,omitempty"`
+}
+
+func (c Category) String() string {
+	return fmt.Sprintf("#%d %s", c.ID, c.Title)
+}
+
+// Categories represents a list of categories.
+type Categories []*Category
+
+// Subscription represents a feed subscription.
+type Subscription struct {
+	Title string `json:"title"`
+	URL   string `json:"url"`
+	Type  string `json:"type"`
+}
+
+func (s Subscription) String() string {
+	return fmt.Sprintf(`Title="%s", URL="%s", Type="%s"`, s.Title, s.URL, s.Type)
+}
+
+// Subscriptions represents a list of subscriptions.
+type Subscriptions []*Subscription
+
+// Feed represents a Miniflux feed.
+type Feed struct {
+	ID                          int64     `json:"id"`
+	UserID                      int64     `json:"user_id"`
+	FeedURL                     string    `json:"feed_url"`
+	SiteURL                     string    `json:"site_url"`
+	Title                       string    `json:"title"`
+	CheckedAt                   time.Time `json:"checked_at,omitempty"`
+	EtagHeader                  string    `json:"etag_header,omitempty"`
+	LastModifiedHeader          string    `json:"last_modified_header,omitempty"`
+	ParsingErrorMsg             string    `json:"parsing_error_message,omitempty"`
+	ParsingErrorCount           int       `json:"parsing_error_count,omitempty"`
+	Disabled                    bool      `json:"disabled"`
+	IgnoreHTTPCache             bool      `json:"ignore_http_cache"`
+	AllowSelfSignedCertificates bool      `json:"allow_self_signed_certificates"`
+	FetchViaProxy               bool      `json:"fetch_via_proxy"`
+	ScraperRules                string    `json:"scraper_rules"`
+	RewriteRules                string    `json:"rewrite_rules"`
+	BlocklistRules              string    `json:"blocklist_rules"`
+	KeeplistRules               string    `json:"keeplist_rules"`
+	Crawler                     bool      `json:"crawler"`
+	UserAgent                   string    `json:"user_agent"`
+	Cookie                      string    `json:"cookie"`
+	Username                    string    `json:"username"`
+	Password                    string    `json:"password"`
+	Category                    *Category `json:"category,omitempty"`
+	HideGlobally                bool      `json:"hide_globally"`
+}
+
+// FeedCreationRequest represents the request to create a feed.
+type FeedCreationRequest struct {
+	FeedURL                     string `json:"feed_url"`
+	CategoryID                  int64  `json:"category_id"`
+	UserAgent                   string `json:"user_agent"`
+	Cookie                      string `json:"cookie"`
+	Username                    string `json:"username"`
+	Password                    string `json:"password"`
+	Crawler                     bool   `json:"crawler"`
+	Disabled                    bool   `json:"disabled"`
+	IgnoreHTTPCache             bool   `json:"ignore_http_cache"`
+	AllowSelfSignedCertificates bool   `json:"allow_self_signed_certificates"`
+	FetchViaProxy               bool   `json:"fetch_via_proxy"`
+	ScraperRules                string `json:"scraper_rules"`
+	RewriteRules                string `json:"rewrite_rules"`
+	BlocklistRules              string `json:"blocklist_rules"`
+	KeeplistRules               string `json:"keeplist_rules"`
+	HideGlobally                bool   `json:"hide_globally"`
+}
+
+// FeedModificationRequest represents the request to update a feed.
+type FeedModificationRequest struct {
+	FeedURL                     *string `json:"feed_url"`
+	SiteURL                     *string `json:"site_url"`
+	Title                       *string `json:"title"`
+	ScraperRules                *string `json:"scraper_rules"`
+	RewriteRules                *string `json:"rewrite_rules"`
+	BlocklistRules              *string `json:"blocklist_rules"`
+	KeeplistRules               *string `json:"keeplist_rules"`
+	Crawler                     *bool   `json:"crawler"`
+	UserAgent                   *string `json:"user_agent"`
+	Cookie                      *string `json:"cookie"`
+	Username                    *string `json:"username"`
+	Password                    *string `json:"password"`
+	CategoryID                  *int64  `json:"category_id"`
+	Disabled                    *bool   `json:"disabled"`
+	IgnoreHTTPCache             *bool   `json:"ignore_http_cache"`
+	AllowSelfSignedCertificates *bool   `json:"allow_self_signed_certificates"`
+	FetchViaProxy               *bool   `json:"fetch_via_proxy"`
+	HideGlobally                *bool   `json:"hide_globally"`
+}
+
+// FeedIcon represents the feed icon.
+type FeedIcon struct {
+	ID       int64  `json:"id"`
+	MimeType string `json:"mime_type"`
+	Data     string `json:"data"`
+}
+
+type FeedCounters struct {
+	ReadCounters   map[int64]int `json:"reads"`
+	UnreadCounters map[int64]int `json:"unreads"`
+}
+
+// Feeds represents a list of feeds.
+type Feeds []*Feed
+
+// Entry represents a subscription item in the system.
+type Entry struct {
+	ID          int64      `json:"id"`
+	UserID      int64      `json:"user_id"`
+	FeedID      int64      `json:"feed_id"`
+	Status      string     `json:"status"`
+	Hash        string     `json:"hash"`
+	Title       string     `json:"title"`
+	URL         string     `json:"url"`
+	CommentsURL string     `json:"comments_url"`
+	Date        time.Time  `json:"published_at"`
+	CreatedAt   time.Time  `json:"created_at"`
+	ChangedAt   time.Time  `json:"changed_at"`
+	Content     string     `json:"content"`
+	Author      string     `json:"author"`
+	ShareCode   string     `json:"share_code"`
+	Starred     bool       `json:"starred"`
+	ReadingTime int        `json:"reading_time"`
+	Enclosures  Enclosures `json:"enclosures,omitempty"`
+	Feed        *Feed      `json:"feed,omitempty"`
+}
+
+// Entries represents a list of entries.
+type Entries []*Entry
+
+// Enclosure represents an attachment.
+type Enclosure struct {
+	ID       int64  `json:"id"`
+	UserID   int64  `json:"user_id"`
+	EntryID  int64  `json:"entry_id"`
+	URL      string `json:"url"`
+	MimeType string `json:"mime_type"`
+	Size     int    `json:"size"`
+}
+
+// Enclosures represents a list of attachments.
+type Enclosures []*Enclosure
+
+const (
+	FilterNotStarred  = "0"
+	FilterOnlyStarred = "1"
+)
+
+// Filter is used to filter entries.
+type Filter struct {
+	Status        string
+	Offset        int
+	Limit         int
+	Order         string
+	Direction     string
+	Starred       string
+	Before        int64
+	After         int64
+	BeforeEntryID int64
+	AfterEntryID  int64
+	Search        string
+	CategoryID    int64
+	FeedID        int64
+	Statuses      []string
+}
+
+// EntryResultSet represents the response when fetching entries.
+type EntryResultSet struct {
+	Total   int     `json:"total"`
+	Entries Entries `json:"entries"`
+}

client/request.go

@@ -1,8 +1,8 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
 
-package miniflux
+package client // import "miniflux.app/client"
 
 import (
 	"bytes"
@@ -10,7 +10,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
 	"net/http"
 	"net/url"
@@ -18,14 +17,16 @@ import (
 )
 
 const (
-	userAgent      = "Miniflux Client Library <https://github.com/miniflux/miniflux-go>"
+	userAgent      = "Miniflux Client Library"
 	defaultTimeout = 80
 )
 
+// List of exposed errors.
 var (
-	errNotAuthorized = errors.New("miniflux: unauthorized (bad credentials)")
-	errForbidden     = errors.New("miniflux: access forbidden")
-	errServerError   = errors.New("miniflux: internal server error")
+	ErrNotAuthorized = errors.New("miniflux: unauthorized (bad credentials)")
+	ErrForbidden     = errors.New("miniflux: access forbidden")
+	ErrServerError   = errors.New("miniflux: internal server error")
+	ErrNotFound      = errors.New("miniflux: resource not found")
 )
 
 type errorResponse struct {
@@ -36,6 +37,7 @@ type request struct {
 	endpoint string
 	username string
 	password string
+	apiKey   string
 }
 
 func (r *request) Get(path string) (io.ReadCloser, error) {
@@ -46,12 +48,17 @@ func (r *request) Post(path string, data interface{}) (io.ReadCloser, error) {
 	return r.execute(http.MethodPost, path, data)
 }
 
+func (r *request) PostFile(path string, f io.ReadCloser) (io.ReadCloser, error) {
+	return r.execute(http.MethodPost, path, f)
+}
+
 func (r *request) Put(path string, data interface{}) (io.ReadCloser, error) {
 	return r.execute(http.MethodPut, path, data)
 }
 
-func (r *request) Delete(path string) (io.ReadCloser, error) {
-	return r.execute(http.MethodDelete, path, nil)
+func (r *request) Delete(path string) error {
+	_, err := r.execute(http.MethodDelete, path, nil)
+	return err
 }
 
 func (r *request) execute(method, path string, data interface{}) (io.ReadCloser, error) {
@@ -69,10 +76,18 @@ func (r *request) execute(method, path string, data interface{}) (io.ReadCloser,
 		Method: method,
 		Header: r.buildHeaders(),
 	}
-	request.SetBasicAuth(r.username, r.password)
+
+	if r.username != "" && r.password != "" {
+		request.SetBasicAuth(r.username, r.password)
+	}
 
 	if data != nil {
-		request.Body = ioutil.NopCloser(bytes.NewBuffer(r.toJSON(data)))
+		switch data := data.(type) {
+		case io.ReadCloser:
+			request.Body = data
+		default:
+			request.Body = io.NopCloser(bytes.NewBuffer(r.toJSON(data)))
+		}
 	}
 
 	client := r.buildClient()
@@ -83,11 +98,27 @@ func (r *request) execute(method, path string, data interface{}) (io.ReadCloser,
 
 	switch response.StatusCode {
 	case http.StatusUnauthorized:
-		return nil, errNotAuthorized
+		response.Body.Close()
+		return nil, ErrNotAuthorized
 	case http.StatusForbidden:
-		return nil, errForbidden
+		response.Body.Close()
+		return nil, ErrForbidden
 	case http.StatusInternalServerError:
-		return nil, errServerError
+		defer response.Body.Close()
+
+		var resp errorResponse
+		decoder := json.NewDecoder(response.Body)
+		// If we failed to decode, just return a generic ErrServerError
+		if err := decoder.Decode(&resp); err != nil {
+			return nil, ErrServerError
+		}
+		return nil, errors.New("miniflux: internal server error: " + resp.ErrorMessage)
+	case http.StatusNotFound:
+		response.Body.Close()
+		return nil, ErrNotFound
+	case http.StatusNoContent:
+		response.Body.Close()
+		return nil, nil
 	case http.StatusBadRequest:
 		defer response.Body.Close()
 
@@ -100,8 +131,9 @@ func (r *request) execute(method, path string, data interface{}) (io.ReadCloser,
 		return nil, fmt.Errorf("miniflux: bad request (%s)", resp.ErrorMessage)
 	}
 
-	if response.StatusCode >= 400 {
-		return nil, fmt.Errorf("miniflux: server error (statusCode=%d)", response.StatusCode)
+	if response.StatusCode > 400 {
+		response.Body.Close()
+		return nil, fmt.Errorf("miniflux: status code=%d", response.StatusCode)
 	}
 
 	return response.Body, nil
@@ -118,6 +150,9 @@ func (r *request) buildHeaders() http.Header {
 	headers.Add("User-Agent", userAgent)
 	headers.Add("Content-Type", "application/json")
 	headers.Add("Accept", "application/json")
+	if r.apiKey != "" {
+		headers.Add("X-Auth-Token", r.apiKey)
+	}
 	return headers
 }
 

config/config.go

@@ -1,178 +1,8 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
+// Copyright 2018 Frédéric Guillot. All rights reserved.
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package config
+package config // import "miniflux.app/config"
 
-import (
-	"net/url"
-	"os"
-	"strconv"
-)
-
-const (
-	defaultBaseURL                 = "http://localhost"
-	defaultDatabaseURL             = "postgres://postgres:postgres@localhost/miniflux2?sslmode=disable"
-	defaultWorkerPoolSize          = 5
-	defaultPollingFrequency        = 60
-	defaultBatchSize               = 10
-	defaultDatabaseMaxConns        = 20
-	defaultListenAddr              = "127.0.0.1:8080"
-	defaultCertFile                = ""
-	defaultKeyFile                 = ""
-	defaultCertDomain              = ""
-	defaultCertCache               = "/tmp/cert_cache"
-	defaultSessionCleanupFrequency = 24
-)
-
-// Config manages configuration parameters.
-type Config struct {
-	IsHTTPS  bool
-	baseURL  string
-	rootURL  string
-	basePath string
-}
-
-func (c *Config) get(key, fallback string) string {
-	value := os.Getenv(key)
-	if value == "" {
-		return fallback
-	}
-
-	return value
-}
-
-func (c *Config) getInt(key string, fallback int) int {
-	value := os.Getenv(key)
-	if value == "" {
-		return fallback
-	}
-
-	v, _ := strconv.Atoi(value)
-	return v
-}
-
-// HasDebugMode returns true if debug mode is enabled.
-func (c *Config) HasDebugMode() bool {
-	return c.get("DEBUG", "") != ""
-}
-
-// BaseURL returns the application base URL with path.
-func (c *Config) BaseURL() string {
-	if c.baseURL == "" {
-		c.baseURL = c.get("BASE_URL", defaultBaseURL)
-		if c.baseURL[len(c.baseURL)-1:] == "/" {
-			c.baseURL = c.baseURL[:len(c.baseURL)-1]
-		}
-	}
-	return c.baseURL
-}
-
-// RootURL returns the base URL without path.
-func (c *Config) RootURL() string {
-	if c.rootURL == "" {
-		u, _ := url.Parse(c.BaseURL())
-		u.Path = ""
-		c.rootURL = u.String()
-	}
-	return c.rootURL
-}
-
-// BasePath returns the application base path according to the base URL.
-func (c *Config) BasePath() string {
-	if c.basePath == "" {
-		u, _ := url.Parse(c.BaseURL())
-		c.basePath = u.Path
-	}
-	return c.basePath
-}
-
-// DatabaseURL returns the database URL.
-func (c *Config) DatabaseURL() string {
-	return c.get("DATABASE_URL", defaultDatabaseURL)
-}
-
-// DatabaseMaxConnections returns the number of maximum database connections.
-func (c *Config) DatabaseMaxConnections() int {
-	return c.getInt("DATABASE_MAX_CONNS", defaultDatabaseMaxConns)
-}
-
-// ListenAddr returns the listen address for the HTTP server.
-func (c *Config) ListenAddr() string {
-	return c.get("LISTEN_ADDR", defaultListenAddr)
-}
-
-// CertFile returns the SSL certificate filename if any.
-func (c *Config) CertFile() string {
-	return c.get("CERT_FILE", defaultCertFile)
-}
-
-// KeyFile returns the private key filename for custom SSL certificate.
-func (c *Config) KeyFile() string {
-	return c.get("KEY_FILE", defaultKeyFile)
-}
-
-// CertDomain returns the domain to use for Let's Encrypt certificate.
-func (c *Config) CertDomain() string {
-	return c.get("CERT_DOMAIN", defaultCertDomain)
-}
-
-// CertCache returns the directory to use for Let's Encrypt session cache.
-func (c *Config) CertCache() string {
-	return c.get("CERT_CACHE", defaultCertCache)
-}
-
-// SessionCleanupFrequency returns the interval for session cleanup.
-func (c *Config) SessionCleanupFrequency() int {
-	return c.getInt("SESSION_CLEANUP_FREQUENCY", defaultSessionCleanupFrequency)
-}
-
-// WorkerPoolSize returns the number of background worker.
-func (c *Config) WorkerPoolSize() int {
-	return c.getInt("WORKER_POOL_SIZE", defaultWorkerPoolSize)
-}
-
-// PollingFrequency returns the interval to refresh feeds in the background.
-func (c *Config) PollingFrequency() int {
-	return c.getInt("POLLING_FREQUENCY", defaultPollingFrequency)
-}
-
-// BatchSize returns the number of feeds to send for background processing.
-func (c *Config) BatchSize() int {
-	return c.getInt("BATCH_SIZE", defaultBatchSize)
-}
-
-// IsOAuth2UserCreationAllowed returns true if user creation is allowed for OAuth2 users.
-func (c *Config) IsOAuth2UserCreationAllowed() bool {
-	return c.getInt("OAUTH2_USER_CREATION", 0) == 1
-}
-
-// OAuth2ClientID returns the OAuth2 Client ID.
-func (c *Config) OAuth2ClientID() string {
-	return c.get("OAUTH2_CLIENT_ID", "")
-}
-
-// OAuth2ClientSecret returns the OAuth2 client secret.
-func (c *Config) OAuth2ClientSecret() string {
-	return c.get("OAUTH2_CLIENT_SECRET", "")
-}
-
-// OAuth2RedirectURL returns the OAuth2 redirect URL.
-func (c *Config) OAuth2RedirectURL() string {
-	return c.get("OAUTH2_REDIRECT_URL", "")
-}
-
-// OAuth2Provider returns the name of the OAuth2 provider configured.
-func (c *Config) OAuth2Provider() string {
-	return c.get("OAUTH2_PROVIDER", "")
-}
-
-// HasHSTS returns true if HTTP Strict Transport Security is enabled.
-func (c *Config) HasHSTS() bool {
-	return c.get("DISABLE_HSTS", "") == ""
-}
-
-// NewConfig returns a new Config.
-func NewConfig() *Config {
-	return &Config{IsHTTPS: os.Getenv("HTTPS") != ""}
-}
+// Opts holds parsed configuration options.
+var Opts *Options

config/doc.go

@@ -1,10 +1,10 @@
-// Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
+// Copyright 2019 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
 
 /*
 
-Package config handles configuration values for Miniflux application.
+Package config handles configuration management for the application.
 
 */
-package config
+package config // import "miniflux.app/config"

config/options.go

@@ -0,0 +1,584 @@
+// Copyright 2019 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package config // import "miniflux.app/config"
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"miniflux.app/version"
+)
+
+const (
+	defaultHTTPS                              = false
+	defaultLogDateTime                        = false
+	defaultHSTS                               = true
+	defaultHTTPService                        = true
+	defaultSchedulerService                   = true
+	defaultDebug                              = false
+	defaultTiming                             = false
+	defaultBaseURL                            = "http://localhost"
+	defaultRootURL                            = "http://localhost"
+	defaultBasePath                           = ""
+	defaultWorkerPoolSize                     = 5
+	defaultPollingFrequency                   = 60
+	defaultBatchSize                          = 100
+	defaultPollingScheduler                   = "round_robin"
+	defaultSchedulerEntryFrequencyMinInterval = 5
+	defaultSchedulerEntryFrequencyMaxInterval = 24 * 60
+	defaultPollingParsingErrorLimit           = 3
+	defaultRunMigrations                      = false
+	defaultDatabaseURL                        = "user=postgres password=postgres dbname=miniflux2 sslmode=disable"
+	defaultDatabaseMaxConns                   = 20
+	defaultDatabaseMinConns                   = 1
+	defaultDatabaseConnectionLifetime         = 5
+	defaultListenAddr                         = "127.0.0.1:8080"
+	defaultCertFile                           = ""
+	defaultKeyFile                            = ""
+	defaultCertDomain                         = ""
+	defaultCleanupFrequencyHours              = 24
+	defaultCleanupArchiveReadDays             = 60
+	defaultCleanupArchiveUnreadDays           = 180
+	defaultCleanupArchiveBatchSize            = 10000
+	defaultCleanupRemoveSessionsDays          = 30
+	defaultProxyImages                        = "http-only"
+	defaultFetchYouTubeWatchTime              = false
+	defaultCreateAdmin                        = false
+	defaultAdminUsername                      = ""
+	defaultAdminPassword                      = ""
+	defaultOAuth2UserCreation                 = false
+	defaultOAuth2ClientID                     = ""
+	defaultOAuth2ClientSecret                 = ""
+	defaultOAuth2RedirectURL                  = ""
+	defaultOAuth2OidcDiscoveryEndpoint        = ""
+	defaultOAuth2Provider                     = ""
+	defaultPocketConsumerKey                  = ""
+	defaultHTTPClientTimeout                  = 20
+	defaultHTTPClientMaxBodySize              = 15
+	defaultHTTPClientProxy                    = ""
+	defaultAuthProxyHeader                    = ""
+	defaultAuthProxyUserCreation              = false
+	defaultMaintenanceMode                    = false
+	defaultMaintenanceMessage                 = "Miniflux is currently under maintenance"
+	defaultMetricsCollector                   = false
+	defaultMetricsRefreshInterval             = 60
+	defaultMetricsAllowedNetworks             = "127.0.0.1/8"
+	defaultWatchdog                           = true
+	defaultInvidiousInstance                  = "yewtu.be"
+)
+
+var defaultHTTPClientUserAgent = "Mozilla/5.0 (compatible; Miniflux/" + version.Version + "; +https://miniflux.app)"
+
+// Option contains a key to value map of a single option. It may be used to output debug strings.
+type Option struct {
+	Key   string
+	Value interface{}
+}
+
+// Options contains configuration options.
+type Options struct {
+	HTTPS                              bool
+	logDateTime                        bool
+	hsts                               bool
+	httpService                        bool
+	schedulerService                   bool
+	debug                              bool
+	serverTimingHeader                 bool
+	baseURL                            string
+	rootURL                            string
+	basePath                           string
+	databaseURL                        string
+	databaseMaxConns                   int
+	databaseMinConns                   int
+	databaseConnectionLifetime         int
+	runMigrations                      bool
+	listenAddr                         string
+	certFile                           string
+	certDomain                         string
+	certKeyFile                        string
+	cleanupFrequencyHours              int
+	cleanupArchiveReadDays             int
+	cleanupArchiveUnreadDays           int
+	cleanupArchiveBatchSize            int
+	cleanupRemoveSessionsDays          int
+	pollingFrequency                   int
+	batchSize                          int
+	pollingScheduler                   string
+	schedulerEntryFrequencyMinInterval int
+	schedulerEntryFrequencyMaxInterval int
+	pollingParsingErrorLimit           int
+	workerPoolSize                     int
+	createAdmin                        bool
+	adminUsername                      string
+	adminPassword                      string
+	proxyImages                        string
+	fetchYouTubeWatchTime              bool
+	oauth2UserCreationAllowed          bool
+	oauth2ClientID                     string
+	oauth2ClientSecret                 string
+	oauth2RedirectURL                  string
+	oauth2OidcDiscoveryEndpoint        string
+	oauth2Provider                     string
+	pocketConsumerKey                  string
+	httpClientTimeout                  int
+	httpClientMaxBodySize              int64
+	httpClientProxy                    string
+	httpClientUserAgent                string
+	authProxyHeader                    string
+	authProxyUserCreation              bool
+	maintenanceMode                    bool
+	maintenanceMessage                 string
+	metricsCollector                   bool
+	metricsRefreshInterval             int
+	metricsAllowedNetworks             []string
+	watchdog                           bool
+	invidiousInstance                  string
+}
+
+// NewOptions returns Options with default values.
+func NewOptions() *Options {
+	return &Options{
+		HTTPS:                              defaultHTTPS,
+		logDateTime:                        defaultLogDateTime,
+		hsts:                               defaultHSTS,
+		httpService:                        defaultHTTPService,
+		schedulerService:                   defaultSchedulerService,
+		debug:                              defaultDebug,
+		serverTimingHeader:                 defaultTiming,
+		baseURL:                            defaultBaseURL,
+		rootURL:                            defaultRootURL,
+		basePath:                           defaultBasePath,
+		databaseURL:                        defaultDatabaseURL,
+		databaseMaxConns:                   defaultDatabaseMaxConns,
+		databaseMinConns:                   defaultDatabaseMinConns,
+		databaseConnectionLifetime:         defaultDatabaseConnectionLifetime,
+		runMigrations:                      defaultRunMigrations,
+		listenAddr:                         defaultListenAddr,
+		certFile:                           defaultCertFile,
+		certDomain:                         defaultCertDomain,
+		certKeyFile:                        defaultKeyFile,
+		cleanupFrequencyHours:              defaultCleanupFrequencyHours,
+		cleanupArchiveReadDays:             defaultCleanupArchiveReadDays,
+		cleanupArchiveUnreadDays:           defaultCleanupArchiveUnreadDays,
+		cleanupArchiveBatchSize:            defaultCleanupArchiveBatchSize,
+		cleanupRemoveSessionsDays:          defaultCleanupRemoveSessionsDays,
+		pollingFrequency:                   defaultPollingFrequency,
+		batchSize:                          defaultBatchSize,
+		pollingScheduler:                   defaultPollingScheduler,
+		schedulerEntryFrequencyMinInterval: defaultSchedulerEntryFrequencyMinInterval,
+		schedulerEntryFrequencyMaxInterval: defaultSchedulerEntryFrequencyMaxInterval,
+		pollingParsingErrorLimit:           defaultPollingParsingErrorLimit,
+		workerPoolSize:                     defaultWorkerPoolSize,
+		createAdmin:                        defaultCreateAdmin,
+		proxyImages:                        defaultProxyImages,
+		fetchYouTubeWatchTime:              defaultFetchYouTubeWatchTime,
+		oauth2UserCreationAllowed:          defaultOAuth2UserCreation,
+		oauth2ClientID:                     defaultOAuth2ClientID,
+		oauth2ClientSecret:                 defaultOAuth2ClientSecret,
+		oauth2RedirectURL:                  defaultOAuth2RedirectURL,
+		oauth2OidcDiscoveryEndpoint:        defaultOAuth2OidcDiscoveryEndpoint,
+		oauth2Provider:                     defaultOAuth2Provider,
+		pocketConsumerKey:                  defaultPocketConsumerKey,
+		httpClientTimeout:                  defaultHTTPClientTimeout,
+		httpClientMaxBodySize:              defaultHTTPClientMaxBodySize * 1024 * 1024,
+		httpClientProxy:                    defaultHTTPClientProxy,
+		httpClientUserAgent:                defaultHTTPClientUserAgent,
+		authProxyHeader:                    defaultAuthProxyHeader,
+		authProxyUserCreation:              defaultAuthProxyUserCreation,
+		maintenanceMode:                    defaultMaintenanceMode,
+		maintenanceMessage:                 defaultMaintenanceMessage,
+		metricsCollector:                   defaultMetricsCollector,
+		metricsRefreshInterval:             defaultMetricsRefreshInterval,
+		metricsAllowedNetworks:             []string{defaultMetricsAllowedNetworks},
+		watchdog:                           defaultWatchdog,
+		invidiousInstance:                  defaultInvidiousInstance,
+	}
+}
+
+// LogDateTime returns true if the date/time should be displayed in log messages.
+func (o *Options) LogDateTime() bool {
+	return o.logDateTime
+}
+
+// HasMaintenanceMode returns true if maintenance mode is enabled.
+func (o *Options) HasMaintenanceMode() bool {
+	return o.maintenanceMode
+}
+
+// MaintenanceMessage returns maintenance message.
+func (o *Options) MaintenanceMessage() string {
+	return o.maintenanceMessage
+}
+
+// HasDebugMode returns true if debug mode is enabled.
+func (o *Options) HasDebugMode() bool {
+	return o.debug
+}
+
+// HasServerTimingHeader returns true if server-timing headers enabled.
+func (o *Options) HasServerTimingHeader() bool {
+	return o.serverTimingHeader
+}
+
+// BaseURL returns the application base URL with path.
+func (o *Options) BaseURL() string {
+	return o.baseURL
+}
+
+// RootURL returns the base URL without path.
+func (o *Options) RootURL() string {
+	return o.rootURL
+}
+
+// BasePath returns the application base path according to the base URL.
+func (o *Options) BasePath() string {
+	return o.basePath
+}
+
+// IsDefaultDatabaseURL returns true if the default database URL is used.
+func (o *Options) IsDefaultDatabaseURL() bool {
+	return o.databaseURL == defaultDatabaseURL
+}
+
+// DatabaseURL returns the database URL.
+func (o *Options) DatabaseURL() string {
+	return o.databaseURL
+}
+
+// DatabaseMaxConns returns the maximum number of database connections.
+func (o *Options) DatabaseMaxConns() int {
+	return o.databaseMaxConns
+}
+
+// DatabaseMinConns returns the minimum number of database connections.
+func (o *Options) DatabaseMinConns() int {
+	return o.databaseMinConns
+}
+
+// DatabaseConnectionLifetime returns the maximum amount of time a connection may be reused.
+func (o *Options) DatabaseConnectionLifetime() time.Duration {
+	return time.Duration(o.databaseConnectionLifetime) * time.Minute
+}
+
+// ListenAddr returns the listen address for the HTTP server.
+func (o *Options) ListenAddr() string {
+	return o.listenAddr
+}
+
+// CertFile returns the SSL certificate filename if any.
+func (o *Options) CertFile() string {
+	return o.certFile
+}
+
+// CertKeyFile returns the private key filename for custom SSL certificate.
+func (o *Options) CertKeyFile() string {
+	return o.certKeyFile
+}
+
+// CertDomain returns the domain to use for Let's Encrypt certificate.
+func (o *Options) CertDomain() string {
+	return o.certDomain
+}
+
+// CleanupFrequencyHours returns the interval in hours for cleanup jobs.
+func (o *Options) CleanupFrequencyHours() int {
+	return o.cleanupFrequencyHours
+}
+
+// CleanupArchiveReadDays returns the number of days after which marking read items as removed.
+func (o *Options) CleanupArchiveReadDays() int {
+	return o.cleanupArchiveReadDays
+}
+
+// CleanupArchiveUnreadDays returns the number of days after which marking unread items as removed.
+func (o *Options) CleanupArchiveUnreadDays() int {
+	return o.cleanupArchiveUnreadDays
+}
+
+// CleanupArchiveBatchSize returns the number of entries to archive for each interval.
+func (o *Options) CleanupArchiveBatchSize() int {
+	return o.cleanupArchiveBatchSize
+}
+
+// CleanupRemoveSessionsDays returns the number of days after which to remove sessions.
+func (o *Options) CleanupRemoveSessionsDays() int {
+	return o.cleanupRemoveSessionsDays
+}
+
+// WorkerPoolSize returns the number of background worker.
+func (o *Options) WorkerPoolSize() int {
+	return o.workerPoolSize
+}
+
+// PollingFrequency returns the interval to refresh feeds in the background.
+func (o *Options) PollingFrequency() int {
+	return o.pollingFrequency
+}
+
+// BatchSize returns the number of feeds to send for background processing.
+func (o *Options) BatchSize() int {
+	return o.batchSize
+}
+
+// PollingScheduler returns the scheduler used for polling feeds.
+func (o *Options) PollingScheduler() string {
+	return o.pollingScheduler
+}
+
+// SchedulerEntryFrequencyMaxInterval returns the maximum interval in minutes for the entry frequency scheduler.
+func (o *Options) SchedulerEntryFrequencyMaxInterval() int {
+	return o.schedulerEntryFrequencyMaxInterval
+}
+
+// SchedulerEntryFrequencyMinInterval returns the minimum interval in minutes for the entry frequency scheduler.
+func (o *Options) SchedulerEntryFrequencyMinInterval() int {
+	return o.schedulerEntryFrequencyMinInterval
+}
+
+// PollingParsingErrorLimit returns the limit of errors when to stop polling.
+func (o *Options) PollingParsingErrorLimit() int {
+	return o.pollingParsingErrorLimit
+}
+
+// IsOAuth2UserCreationAllowed returns true if user creation is allowed for OAuth2 users.
+func (o *Options) IsOAuth2UserCreationAllowed() bool {
+	return o.oauth2UserCreationAllowed
+}
+
+// OAuth2ClientID returns the OAuth2 Client ID.
+func (o *Options) OAuth2ClientID() string {
+	return o.oauth2ClientID
+}
+
+// OAuth2ClientSecret returns the OAuth2 client secret.
+func (o *Options) OAuth2ClientSecret() string {
+	return o.oauth2ClientSecret
+}
+
+// OAuth2RedirectURL returns the OAuth2 redirect URL.
+func (o *Options) OAuth2RedirectURL() string {
+	return o.oauth2RedirectURL
+}
+
+// OAuth2OidcDiscoveryEndpoint returns the OAuth2 OIDC discovery endpoint.
+func (o *Options) OAuth2OidcDiscoveryEndpoint() string {
+	return o.oauth2OidcDiscoveryEndpoint
+}
+
+// OAuth2Provider returns the name of the OAuth2 provider configured.
+func (o *Options) OAuth2Provider() string {
+	return o.oauth2Provider
+}
+
+// HasHSTS returns true if HTTP Strict Transport Security is enabled.
+func (o *Options) HasHSTS() bool {
+	return o.hsts
+}
+
+// RunMigrations returns true if the environment variable RUN_MIGRATIONS is not empty.
+func (o *Options) RunMigrations() bool {
+	return o.runMigrations
+}
+
+// CreateAdmin returns true if the environment variable CREATE_ADMIN is not empty.
+func (o *Options) CreateAdmin() bool {
+	return o.createAdmin
+}
+
+// AdminUsername returns the admin username if defined.
+func (o *Options) AdminUsername() string {
+	return o.adminUsername
+}
+
+// AdminPassword returns the admin password if defined.
+func (o *Options) AdminPassword() string {
+	return o.adminPassword
+}
+
+// FetchYouTubeWatchTime returns true if the YouTube video duration
+// should be fetched and used as a reading time.
+func (o *Options) FetchYouTubeWatchTime() bool {
+	return o.fetchYouTubeWatchTime
+}
+
+// ProxyImages returns "none" to never proxy, "http-only" to proxy non-HTTPS, "all" to always proxy.
+func (o *Options) ProxyImages() string {
+	return o.proxyImages
+}
+
+// HasHTTPService returns true if the HTTP service is enabled.
+func (o *Options) HasHTTPService() bool {
+	return o.httpService
+}
+
+// HasSchedulerService returns true if the scheduler service is enabled.
+func (o *Options) HasSchedulerService() bool {
+	return o.schedulerService
+}
+
+// PocketConsumerKey returns the Pocket Consumer Key if configured.
+func (o *Options) PocketConsumerKey(defaultValue string) string {
+	if o.pocketConsumerKey != "" {
+		return o.pocketConsumerKey
+	}
+	return defaultValue
+}
+
+// HTTPClientTimeout returns the time limit in seconds before the HTTP client cancel the request.
+func (o *Options) HTTPClientTimeout() int {
+	return o.httpClientTimeout
+}
+
+// HTTPClientMaxBodySize returns the number of bytes allowed for the HTTP client to transfer.
+func (o *Options) HTTPClientMaxBodySize() int64 {
+	return o.httpClientMaxBodySize
+}
+
+// HTTPClientProxy returns the proxy URL for HTTP client.
+func (o *Options) HTTPClientProxy() string {
+	return o.httpClientProxy
+}
+
+// HasHTTPClientProxyConfigured returns true if the HTTP proxy is configured.
+func (o *Options) HasHTTPClientProxyConfigured() bool {
+	return o.httpClientProxy != ""
+}
+
+// AuthProxyHeader returns an HTTP header name that contains username for
+// authentication using auth proxy.
+func (o *Options) AuthProxyHeader() string {
+	return o.authProxyHeader
+}
+
+// IsAuthProxyUserCreationAllowed returns true if user creation is allowed for
+// users authenticated using auth proxy.
+func (o *Options) IsAuthProxyUserCreationAllowed() bool {
+	return o.authProxyUserCreation
+}
+
+// HasMetricsCollector returns true if metrics collection is enabled.
+func (o *Options) HasMetricsCollector() bool {
+	return o.metricsCollector
+}
+
+// MetricsRefreshInterval returns the refresh interval in seconds.
+func (o *Options) MetricsRefreshInterval() int {
+	return o.metricsRefreshInterval
+}
+
+// MetricsAllowedNetworks returns the list of networks allowed to connect to the metrics endpoint.
+func (o *Options) MetricsAllowedNetworks() []string {
+	return o.metricsAllowedNetworks
+}
+
+// HTTPClientUserAgent returns the global User-Agent header for miniflux.
+func (o *Options) HTTPClientUserAgent() string {
+	return o.httpClientUserAgent
+}
+
+// HasWatchdog returns true if the systemd watchdog is enabled.
+func (o *Options) HasWatchdog() bool {
+	return o.watchdog
+}
+
+// InvidiousInstance returns the invidious instance used by miniflux
+func (o *Options) InvidiousInstance() string {
+	return o.invidiousInstance
+}
+
+// SortedOptions returns options as a list of key value pairs, sorted by keys.
+func (o *Options) SortedOptions(redactSecret bool) []*Option {
+	var keyValues = map[string]interface{}{
+		"ADMIN_PASSWORD":                         redactSecretValue(o.adminPassword, redactSecret),
+		"ADMIN_USERNAME":                         o.adminUsername,
+		"AUTH_PROXY_HEADER":                      o.authProxyHeader,
+		"AUTH_PROXY_USER_CREATION":               o.authProxyUserCreation,
+		"BASE_PATH":                              o.basePath,
+		"BASE_URL":                               o.baseURL,
+		"BATCH_SIZE":                             o.batchSize,
+		"CERT_DOMAIN":                            o.certDomain,
+		"CERT_FILE":                              o.certFile,
+		"CLEANUP_ARCHIVE_READ_DAYS":              o.cleanupArchiveReadDays,
+		"CLEANUP_ARCHIVE_UNREAD_DAYS":            o.cleanupArchiveUnreadDays,
+		"CLEANUP_ARCHIVE_BATCH_SIZE":             o.cleanupArchiveBatchSize,
+		"CLEANUP_FREQUENCY_HOURS":                o.cleanupFrequencyHours,
+		"CLEANUP_REMOVE_SESSIONS_DAYS":           o.cleanupRemoveSessionsDays,
+		"CREATE_ADMIN":                           o.createAdmin,
+		"DATABASE_MAX_CONNS":                     o.databaseMaxConns,
+		"DATABASE_MIN_CONNS":                     o.databaseMinConns,
+		"DATABASE_CONNECTION_LIFETIME":           o.databaseConnectionLifetime,
+		"DATABASE_URL":                           redactSecretValue(o.databaseURL, redactSecret),
+		"DEBUG":                                  o.debug,
+		"DISABLE_HSTS":                           !o.hsts,
+		"DISABLE_SCHEDULER_SERVICE":              !o.schedulerService,
+		"DISABLE_HTTP_SERVICE":                   !o.httpService,
+		"FETCH_YOUTUBE_WATCH_TIME":               o.fetchYouTubeWatchTime,
+		"HTTPS":                                  o.HTTPS,
+		"HTTP_CLIENT_MAX_BODY_SIZE":              o.httpClientMaxBodySize,
+		"HTTP_CLIENT_PROXY":                      o.httpClientProxy,
+		"HTTP_CLIENT_TIMEOUT":                    o.httpClientTimeout,
+		"HTTP_CLIENT_USER_AGENT":                 o.httpClientUserAgent,
+		"HTTP_SERVICE":                           o.httpService,
+		"KEY_FILE":                               o.certKeyFile,
+		"INVIDIOUS_INSTANCE":                     o.invidiousInstance,
+		"LISTEN_ADDR":                            o.listenAddr,
+		"LOG_DATE_TIME":                          o.logDateTime,
+		"MAINTENANCE_MESSAGE":                    o.maintenanceMessage,
+		"MAINTENANCE_MODE":                       o.maintenanceMode,
+		"METRICS_ALLOWED_NETWORKS":               strings.Join(o.metricsAllowedNetworks, ","),
+		"METRICS_COLLECTOR":                      o.metricsCollector,
+		"METRICS_REFRESH_INTERVAL":               o.metricsRefreshInterval,
+		"OAUTH2_CLIENT_ID":                       o.oauth2ClientID,
+		"OAUTH2_CLIENT_SECRET":                   redactSecretValue(o.oauth2ClientSecret, redactSecret),
+		"OAUTH2_OIDC_DISCOVERY_ENDPOINT":         o.oauth2OidcDiscoveryEndpoint,
+		"OAUTH2_PROVIDER":                        o.oauth2Provider,
+		"OAUTH2_REDIRECT_URL":                    o.oauth2RedirectURL,
+		"OAUTH2_USER_CREATION":                   o.oauth2UserCreationAllowed,
+		"POCKET_CONSUMER_KEY":                    redactSecretValue(o.pocketConsumerKey, redactSecret),
+		"POLLING_FREQUENCY":                      o.pollingFrequency,
+		"POLLING_PARSING_ERROR_LIMIT":            o.pollingParsingErrorLimit,
+		"POLLING_SCHEDULER":                      o.pollingScheduler,
+		"PROXY_IMAGES":                           o.proxyImages,
+		"ROOT_URL":                               o.rootURL,
+		"RUN_MIGRATIONS":                         o.runMigrations,
+		"SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL": o.schedulerEntryFrequencyMaxInterval,
+		"SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL": o.schedulerEntryFrequencyMinInterval,
+		"SCHEDULER_SERVICE":                      o.schedulerService,
+		"SERVER_TIMING_HEADER":                   o.serverTimingHeader,
+		"WORKER_POOL_SIZE":                       o.workerPoolSize,
+		"WATCHDOG":                               o.watchdog,
+	}
+
+	keys := make([]string, 0, len(keyValues))
+	for key := range keyValues {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+
+	var sortedOptions []*Option
+	for _, key := range keys {
+		sortedOptions = append(sortedOptions, &Option{Key: key, Value: keyValues[key]})
+	}
+	return sortedOptions
+}
+
+func (o *Options) String() string {
+	var builder strings.Builder
+
+	for _, option := range o.SortedOptions(false) {
+		fmt.Fprintf(&builder, "%s=%v\n", option.Key, option.Value)
+	}
+
+	return builder.String()
+}
+
+func redactSecretValue(value string, redactSecret bool) string {
+	if redactSecret && value != "" {
+		return "******"
+	}
+	return value
+}

config/parser.go

@@ -0,0 +1,292 @@
+// Copyright 2019 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package config // import "miniflux.app/config"
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	url_parser "net/url"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// Parser handles configuration parsing.
+type Parser struct {
+	opts *Options
+}
+
+// NewParser returns a new Parser.
+func NewParser() *Parser {
+	return &Parser{
+		opts: NewOptions(),
+	}
+}
+
+// ParseEnvironmentVariables loads configuration values from environment variables.
+func (p *Parser) ParseEnvironmentVariables() (*Options, error) {
+	err := p.parseLines(os.Environ())
+	if err != nil {
+		return nil, err
+	}
+	return p.opts, nil
+}
+
+// ParseFile loads configuration values from a local file.
+func (p *Parser) ParseFile(filename string) (*Options, error) {
+	fp, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer fp.Close()
+
+	err = p.parseLines(p.parseFileContent(fp))
+	if err != nil {
+		return nil, err
+	}
+	return p.opts, nil
+}
+
+func (p *Parser) parseFileContent(r io.Reader) (lines []string) {
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if len(line) > 0 && !strings.HasPrefix(line, "#") && strings.Index(line, "=") > 0 {
+			lines = append(lines, line)
+		}
+	}
+	return lines
+}
+
+func (p *Parser) parseLines(lines []string) (err error) {
+	var port string
+
+	for _, line := range lines {
+		fields := strings.SplitN(line, "=", 2)
+		key := strings.TrimSpace(fields[0])
+		value := strings.TrimSpace(fields[1])
+
+		switch key {
+		case "LOG_DATE_TIME":
+			p.opts.logDateTime = parseBool(value, defaultLogDateTime)
+		case "DEBUG":
+			p.opts.debug = parseBool(value, defaultDebug)
+		case "SERVER_TIMING_HEADER":
+			p.opts.serverTimingHeader = parseBool(value, defaultTiming)
+		case "BASE_URL":
+			p.opts.baseURL, p.opts.rootURL, p.opts.basePath, err = parseBaseURL(value)
+			if err != nil {
+				return err
+			}
+		case "PORT":
+			port = value
+		case "LISTEN_ADDR":
+			p.opts.listenAddr = parseString(value, defaultListenAddr)
+		case "DATABASE_URL":
+			p.opts.databaseURL = parseString(value, defaultDatabaseURL)
+		case "DATABASE_URL_FILE":
+			p.opts.databaseURL = readSecretFile(value, defaultDatabaseURL)
+		case "DATABASE_MAX_CONNS":
+			p.opts.databaseMaxConns = parseInt(value, defaultDatabaseMaxConns)
+		case "DATABASE_MIN_CONNS":
+			p.opts.databaseMinConns = parseInt(value, defaultDatabaseMinConns)
+		case "DATABASE_CONNECTION_LIFETIME":
+			p.opts.databaseConnectionLifetime = parseInt(value, defaultDatabaseConnectionLifetime)
+		case "RUN_MIGRATIONS":
+			p.opts.runMigrations = parseBool(value, defaultRunMigrations)
+		case "DISABLE_HSTS":
+			p.opts.hsts = !parseBool(value, defaultHSTS)
+		case "HTTPS":
+			p.opts.HTTPS = parseBool(value, defaultHTTPS)
+		case "DISABLE_SCHEDULER_SERVICE":
+			p.opts.schedulerService = !parseBool(value, defaultSchedulerService)
+		case "DISABLE_HTTP_SERVICE":
+			p.opts.httpService = !parseBool(value, defaultHTTPService)
+		case "CERT_FILE":
+			p.opts.certFile = parseString(value, defaultCertFile)
+		case "KEY_FILE":
+			p.opts.certKeyFile = parseString(value, defaultKeyFile)
+		case "CERT_DOMAIN":
+			p.opts.certDomain = parseString(value, defaultCertDomain)
+		case "CLEANUP_FREQUENCY_HOURS":
+			p.opts.cleanupFrequencyHours = parseInt(value, defaultCleanupFrequencyHours)
+		case "CLEANUP_ARCHIVE_READ_DAYS":
+			p.opts.cleanupArchiveReadDays = parseInt(value, defaultCleanupArchiveReadDays)
+		case "CLEANUP_ARCHIVE_UNREAD_DAYS":
+			p.opts.cleanupArchiveUnreadDays = parseInt(value, defaultCleanupArchiveUnreadDays)
+		case "CLEANUP_ARCHIVE_BATCH_SIZE":
+			p.opts.cleanupArchiveBatchSize = parseInt(value, defaultCleanupArchiveBatchSize)
+		case "CLEANUP_REMOVE_SESSIONS_DAYS":
+			p.opts.cleanupRemoveSessionsDays = parseInt(value, defaultCleanupRemoveSessionsDays)
+		case "WORKER_POOL_SIZE":
+			p.opts.workerPoolSize = parseInt(value, defaultWorkerPoolSize)
+		case "POLLING_FREQUENCY":
+			p.opts.pollingFrequency = parseInt(value, defaultPollingFrequency)
+		case "BATCH_SIZE":
+			p.opts.batchSize = parseInt(value, defaultBatchSize)
+		case "POLLING_SCHEDULER":
+			p.opts.pollingScheduler = strings.ToLower(parseString(value, defaultPollingScheduler))
+		case "SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL":
+			p.opts.schedulerEntryFrequencyMaxInterval = parseInt(value, defaultSchedulerEntryFrequencyMaxInterval)
+		case "SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL":
+			p.opts.schedulerEntryFrequencyMinInterval = parseInt(value, defaultSchedulerEntryFrequencyMinInterval)
+		case "POLLING_PARSING_ERROR_LIMIT":
+			p.opts.pollingParsingErrorLimit = parseInt(value, defaultPollingParsingErrorLimit)
+		case "PROXY_IMAGES":
+			p.opts.proxyImages = parseString(value, defaultProxyImages)
+		case "CREATE_ADMIN":
+			p.opts.createAdmin = parseBool(value, defaultCreateAdmin)
+		case "ADMIN_USERNAME":
+			p.opts.adminUsername = parseString(value, defaultAdminUsername)
+		case "ADMIN_USERNAME_FILE":
+			p.opts.adminUsername = readSecretFile(value, defaultAdminUsername)
+		case "ADMIN_PASSWORD":
+			p.opts.adminPassword = parseString(value, defaultAdminPassword)
+		case "ADMIN_PASSWORD_FILE":
+			p.opts.adminPassword = readSecretFile(value, defaultAdminPassword)
+		case "POCKET_CONSUMER_KEY":
+			p.opts.pocketConsumerKey = parseString(value, defaultPocketConsumerKey)
+		case "POCKET_CONSUMER_KEY_FILE":
+			p.opts.pocketConsumerKey = readSecretFile(value, defaultPocketConsumerKey)
+		case "OAUTH2_USER_CREATION":
+			p.opts.oauth2UserCreationAllowed = parseBool(value, defaultOAuth2UserCreation)
+		case "OAUTH2_CLIENT_ID":
+			p.opts.oauth2ClientID = parseString(value, defaultOAuth2ClientID)
+		case "OAUTH2_CLIENT_ID_FILE":
+			p.opts.oauth2ClientID = readSecretFile(value, defaultOAuth2ClientID)
+		case "OAUTH2_CLIENT_SECRET":
+			p.opts.oauth2ClientSecret = parseString(value, defaultOAuth2ClientSecret)
+		case "OAUTH2_CLIENT_SECRET_FILE":
+			p.opts.oauth2ClientSecret = readSecretFile(value, defaultOAuth2ClientSecret)
+		case "OAUTH2_REDIRECT_URL":
+			p.opts.oauth2RedirectURL = parseString(value, defaultOAuth2RedirectURL)
+		case "OAUTH2_OIDC_DISCOVERY_ENDPOINT":
+			p.opts.oauth2OidcDiscoveryEndpoint = parseString(value, defaultOAuth2OidcDiscoveryEndpoint)
+		case "OAUTH2_PROVIDER":
+			p.opts.oauth2Provider = parseString(value, defaultOAuth2Provider)
+		case "HTTP_CLIENT_TIMEOUT":
+			p.opts.httpClientTimeout = parseInt(value, defaultHTTPClientTimeout)
+		case "HTTP_CLIENT_MAX_BODY_SIZE":
+			p.opts.httpClientMaxBodySize = int64(parseInt(value, defaultHTTPClientMaxBodySize) * 1024 * 1024)
+		case "HTTP_CLIENT_PROXY":
+			p.opts.httpClientProxy = parseString(value, defaultHTTPClientProxy)
+		case "HTTP_CLIENT_USER_AGENT":
+			p.opts.httpClientUserAgent = parseString(value, defaultHTTPClientUserAgent)
+		case "AUTH_PROXY_HEADER":
+			p.opts.authProxyHeader = parseString(value, defaultAuthProxyHeader)
+		case "AUTH_PROXY_USER_CREATION":
+			p.opts.authProxyUserCreation = parseBool(value, defaultAuthProxyUserCreation)
+		case "MAINTENANCE_MODE":
+			p.opts.maintenanceMode = parseBool(value, defaultMaintenanceMode)
+		case "MAINTENANCE_MESSAGE":
+			p.opts.maintenanceMessage = parseString(value, defaultMaintenanceMessage)
+		case "METRICS_COLLECTOR":
+			p.opts.metricsCollector = parseBool(value, defaultMetricsCollector)
+		case "METRICS_REFRESH_INTERVAL":
+			p.opts.metricsRefreshInterval = parseInt(value, defaultMetricsRefreshInterval)
+		case "METRICS_ALLOWED_NETWORKS":
+			p.opts.metricsAllowedNetworks = parseStringList(value, []string{defaultMetricsAllowedNetworks})
+		case "FETCH_YOUTUBE_WATCH_TIME":
+			p.opts.fetchYouTubeWatchTime = parseBool(value, defaultFetchYouTubeWatchTime)
+		case "WATCHDOG":
+			p.opts.watchdog = parseBool(value, defaultWatchdog)
+		case "INVIDIOUS_INSTANCE":
+			p.opts.invidiousInstance = parseString(value, defaultInvidiousInstance)
+		}
+	}
+
+	if port != "" {
+		p.opts.listenAddr = ":" + port
+	}
+	return nil
+}
+
+func parseBaseURL(value string) (string, string, string, error) {
+	if value == "" {
+		return defaultBaseURL, defaultRootURL, "", nil
+	}
+
+	if value[len(value)-1:] == "/" {
+		value = value[:len(value)-1]
+	}
+
+	url, err := url_parser.Parse(value)
+	if err != nil {
+		return "", "", "", fmt.Errorf("config: invalid BASE_URL: %w", err)
+	}
+
+	scheme := strings.ToLower(url.Scheme)
+	if scheme != "https" && scheme != "http" {
+		return "", "", "", errors.New("config: invalid BASE_URL: scheme must be http or https")
+	}
+
+	basePath := url.Path
+	url.Path = ""
+	return value, url.String(), basePath, nil
+}
+
+func parseBool(value string, fallback bool) bool {
+	if value == "" {
+		return fallback
+	}
+
+	value = strings.ToLower(value)
+	if value == "1" || value == "yes" || value == "true" || value == "on" {
+		return true
+	}
+
+	return false
+}
+
+func parseInt(value string, fallback int) int {
+	if value == "" {
+		return fallback
+	}
+
+	v, err := strconv.Atoi(value)
+	if err != nil {
+		return fallback
+	}
+
+	return v
+}
+
+func parseString(value string, fallback string) string {
+	if value == "" {
+		return fallback
+	}
+	return value
+}
+
+func parseStringList(value string, fallback []string) []string {
+	if value == "" {
+		return fallback
+	}
+
+	var strList []string
+	items := strings.Split(value, ",")
+	for _, item := range items {
+		strList = append(strList, strings.TrimSpace(item))
+	}
+
+	return strList
+}
+
+func readSecretFile(filename, fallback string) string {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return fallback
+	}
+
+	value := string(bytes.TrimSpace(data))
+	if value == "" {
+		return fallback
+	}
+
+	return value
+}

config/parser_test.go

@@ -0,0 +1,61 @@
+// Copyright 2019 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package config // import "miniflux.app/config"
+
+import (
+	"testing"
+)
+
+func TestParseBoolValue(t *testing.T) {
+	scenarios := map[string]bool{
+		"":        true,
+		"1":       true,
+		"Yes":     true,
+		"yes":     true,
+		"True":    true,
+		"true":    true,
+		"on":      true,
+		"false":   false,
+		"off":     false,
+		"invalid": false,
+	}
+
+	for input, expected := range scenarios {
+		result := parseBool(input, true)
+		if result != expected {
+			t.Errorf(`Unexpected result for %q, got %v instead of %v`, input, result, expected)
+		}
+	}
+}
+
+func TestParseStringValueWithUnsetVariable(t *testing.T) {
+	if parseString("", "defaultValue") != "defaultValue" {
+		t.Errorf(`Unset variables should returns the default value`)
+	}
+}
+
+func TestParseStringValue(t *testing.T) {
+	if parseString("test", "defaultValue") != "test" {
+		t.Errorf(`Defined variables should returns the specified value`)
+	}
+}
+
+func TestParseIntValueWithUnsetVariable(t *testing.T) {
+	if parseInt("", 42) != 42 {
+		t.Errorf(`Unset variables should returns the default value`)
+	}
+}
+
+func TestParseIntValueWithInvalidInput(t *testing.T) {
+	if parseInt("invalid integer", 42) != 42 {
+		t.Errorf(`Invalid integer should returns the default value`)
+	}
+}
+
+func TestParseIntValue(t *testing.T) {
+	if parseInt("2018", 42) != 2018 {
+		t.Errorf(`Defined variables should returns the specified value`)
+	}
+}

contrib/README.md

@@ -0,0 +1,4 @@
+The contrib directory contains various useful things contributed by the community.
+
+Community contributions are not officially supported by the maintainers.
+There is no guarantee whatsoever that anything in this folder works.

contrib/ansible/inventories/group_vars/miniflux_vars.yml

@@ -0,0 +1,8 @@
+---
+  miniflux_linux_user: miniflux
+  miniflux_db_user_name: miniflux_db_user
+  miniflux_db_user_password: miniflux_db_user_password
+  miniflux_db: miniflux_db
+  miniflux_admin_name: admin
+  miniflux_admin_passwort: miniflux_admin_password
+  miniflux_port: 8080

contrib/ansible/playbooks/playbook.yml

@@ -0,0 +1,4 @@
+---
+- hosts: miniflux
+  roles:
+    - { role: mgrote.miniflux, tags: "miniflux" }

contrib/ansible/roles/mgrote.miniflux/README.md

@@ -0,0 +1,23 @@
+## mgrote.miniflux
+
+### Details
+Installs and configures Miniflux v2 with ansible
+
+### Works on...
+- [x] Ubuntu (>=18.04)
+
+### Variables and Defaults
+##### Linux User
+    miniflux_linux_user: miniflux
+##### DB User
+    miniflux_db_user_name: miniflux_db_user
+##### DB Password
+    miniflux_db_user_password: qqqqqqqqqqqqq
+##### Database
+    miniflux_db: miniflux_db
+##### Username Miniflux Admin
+    miniflux_admin_name: admin
+##### Password Miniflux Admin
+    miniflux_admin_passwort: hallowelt
+##### Port for Miniflux Frontend
+    miniflux_port: 8080

contrib/ansible/roles/mgrote.miniflux/handlers/main.yml

@@ -0,0 +1,11 @@
+---
+  - name: start_miniflux.service
+    become: yes
+    systemd:
+      name: miniflux
+      state: restarted
+      enabled: yes
+# wait 15 seconds(for systemd)
+  - name: miniflux_wait
+    wait_for:
+      timeout: 15

contrib/ansible/roles/mgrote.miniflux/tasks/main.yml

@@ -0,0 +1,43 @@
+  - name: add Apt-key for miniflux-repo
+    become: yes
+    apt_key:
+      url: https://apt.miniflux.app/KEY.gpg
+      state: present
+
+  - name: add miniflux-repo
+    become: yes
+    apt_repository:
+      repo: 'deb https://apt.miniflux.app/ /' 
+      state: present
+      filename: miniflux_repo
+      update_cache: yes
+
+  - name: install miniflux
+    become: yes
+    apt:
+      name: miniflux
+      state: present
+
+  - name: add miniflux linux_user
+    become: yes
+    user:
+      name: "{{ miniflux_linux_user }}"
+      home: "/var/empty"
+      create_home: "no"
+      system: "yes"
+      shell: "/bin/false"
+
+  - name: create directory "/etc/miniflux.d"
+    become: yes
+    file:
+      path: /etc/miniflux.d
+      state: directory
+
+  - name: copy miniflux.conf
+    become: yes
+    template:
+      src: "miniflux.conf"
+      dest: "/etc/miniflux.conf"
+    notify:
+      - start_miniflux.service
+      - miniflux_wait

contrib/ansible/roles/mgrote.miniflux/templates/miniflux.conf

@@ -0,0 +1,18 @@
+# See https://docs.miniflux.app/
+
+LISTEN_ADDR=0.0.0.0:{{ miniflux_port }}
+DATABASE_URL=user={{ miniflux_db_user_name }} password={{ miniflux_db_user_password }} dbname={{ miniflux_db }} sslmode=disable
+
+POLLING_FREQUENCY=15
+PROXY_IMAGES=http-only
+
+# Run SQL migrations automatically:
+RUN_MIGRATIONS=1
+
+CREATE_ADMIN=1
+ADMIN_USERNAME={{ miniflux_admin_name }}
+ADMIN_PASSWORD={{ miniflux_admin_passwort }}
+
+POLLING_FREQUENCY=10
+
+# Options: https://miniflux.app/miniflux.1.html

contrib/docker-compose/Caddyfile

@@ -0,0 +1,2 @@
+miniflux.example.org
+reverse_proxy miniflux:8080

contrib/docker-compose/README.md

@@ -0,0 +1,13 @@
+Docker-Compose Examples
+=======================
+
+Here are few Docker Compose examples:
+
+- `basic.yml`: Basic example
+- `caddy.yml`: Use Caddy as reverse-proxy with automatic HTTPS
+- `traefik.yml`: Use Traefik as reverse-proxy with automatic HTTPS
+
+```bash
+docker-compose -f basic.yml up -d db
+docker-compose -f basic.yml up
+```

contrib/docker-compose/basic.yml

@@ -0,0 +1,34 @@
+version: '3.4'
+services:
+  miniflux:
+    image: ${MINIFLUX_IMAGE:-miniflux/miniflux:latest}
+    container_name: miniflux
+    restart: always
+    ports:
+      - "80:8080"
+    depends_on:
+      - db
+    environment:
+      - DATABASE_URL=postgres://miniflux:secret@db/miniflux?sslmode=disable
+      - RUN_MIGRATIONS=1
+      - CREATE_ADMIN=1
+      - ADMIN_USERNAME=admin
+      - ADMIN_PASSWORD=test123
+      - DEBUG=1
+    # Optional health check:
+    # healthcheck:
+    #  test: ["CMD", "/usr/bin/miniflux", "-healthcheck", "auto"]
+  db:
+    image: postgres:latest
+    container_name: postgres
+    environment:
+      - POSTGRES_USER=miniflux
+      - POSTGRES_PASSWORD=secret
+    volumes:
+      - miniflux-db:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD", "pg_isready", "-U", "miniflux"]
+      interval: 10s
+      start_period: 30s
+volumes:
+  miniflux-db:

contrib/docker-compose/caddy.yml

@@ -0,0 +1,42 @@
+version: '3.4'
+services:
+  caddy:
+    image: caddy:2
+    container_name: caddy
+    depends_on:
+      - miniflux
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - $PWD/Caddyfile:/etc/caddy/Caddyfile
+      - caddy_data:/data
+      - caddy_config:/config
+  miniflux:
+    image: ${MINIFLUX_IMAGE:-miniflux/miniflux:latest}
+    container_name: miniflux
+    depends_on:
+      - db
+    environment:
+      - DATABASE_URL=postgres://miniflux:secret@db/miniflux?sslmode=disable
+      - RUN_MIGRATIONS=1
+      - CREATE_ADMIN=1
+      - ADMIN_USERNAME=admin
+      - ADMIN_PASSWORD=test123
+      - BASE_URL=https://miniflux.example.org
+  db:
+    image: postgres:latest
+    container_name: postgres
+    environment:
+      - POSTGRES_USER=miniflux
+      - POSTGRES_PASSWORD=secret
+    volumes:
+      - miniflux-db:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD", "pg_isready", "-U", "miniflux"]
+      interval: 10s
+      start_period: 30s
+volumes:
+  miniflux-db:
+  caddy_data:
+  caddy_config:

contrib/docker-compose/traefik.yml

@@ -0,0 +1,52 @@
+version: '3.4'
+services:
+  traefik:
+    image: "traefik:v2.3"
+    container_name: traefik
+    command:
+      - "--providers.docker=true"
+      - "--providers.docker.exposedbydefault=false"
+      - "--entrypoints.websecure.address=:443"
+      - "--certificatesresolvers.myresolver.acme.tlschallenge=true"
+      - "--certificatesresolvers.myresolver.acme.email=postmaster@example.com"
+      - "--certificatesresolvers.myresolver.acme.storage=/letsencrypt/acme.json"
+    depends_on:
+      - miniflux
+    ports:
+      - "443:443"
+    volumes:
+      - "./letsencrypt:/letsencrypt"
+      - "/var/run/docker.sock:/var/run/docker.sock:ro"
+  miniflux:
+    image: ${MINIFLUX_IMAGE:-miniflux/miniflux:latest}
+    container_name: miniflux
+    depends_on:
+      - db
+    expose:
+      - "8080"
+    environment:
+      - DATABASE_URL=postgres://miniflux:secret@db/miniflux?sslmode=disable
+      - RUN_MIGRATIONS=1
+      - CREATE_ADMIN=1
+      - ADMIN_USERNAME=admin
+      - ADMIN_PASSWORD=test123
+      - BASE_URL=https://miniflux.example.org
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.miniflux.rule=Host(`miniflux.example.org`)"
+      - "traefik.http.routers.miniflux.entrypoints=websecure"
+      - "traefik.http.routers.miniflux.tls.certresolver=myresolver"
+  db:
+    image: postgres:latest
+    container_name: postgres
+    environment:
+      - POSTGRES_USER=miniflux
+      - POSTGRES_PASSWORD=secret
+    volumes:
+      - miniflux-db:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD", "pg_isready", "-U", "miniflux"]
+      interval: 10s
+      start_period: 30s
+volumes:
+  miniflux-db:

contrib/grafana/README.md

@@ -0,0 +1 @@
+Grafana Dashboard for Miniflux

crypto/crypto.go

@@ -2,12 +2,13 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package crypto
+package crypto // import "miniflux.app/crypto"
 
 import (
 	"crypto/rand"
 	"crypto/sha256"
 	"encoding/base64"
+	"encoding/hex"
 	"fmt"
 )
 
@@ -36,3 +37,8 @@ func GenerateRandomBytes(size int) []byte {
 func GenerateRandomString(size int) string {
 	return base64.URLEncoding.EncodeToString(GenerateRandomBytes(size))
 }
+
+// GenerateRandomStringHex returns a random hexadecimal string.
+func GenerateRandomStringHex(size int) string {
+	return hex.EncodeToString(GenerateRandomBytes(size))
+}

crypto/doc.go

@@ -1,10 +1,10 @@
 // Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
 
 /*
 
 Package crypto implements helpers related to cryptography.
 
 */
-package crypto
+package crypto // import "miniflux.app/crypto"

daemon/daemon.go

@@ -1,48 +0,0 @@
-// Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package daemon
-
-import (
-	"context"
-	"os"
-	"os/signal"
-	"syscall"
-	"time"
-
-	"github.com/miniflux/miniflux/config"
-	"github.com/miniflux/miniflux/logger"
-	"github.com/miniflux/miniflux/reader/feed"
-	"github.com/miniflux/miniflux/scheduler"
-	"github.com/miniflux/miniflux/storage"
-)
-
-// Run starts the daemon.
-func Run(cfg *config.Config, store *storage.Storage) {
-	logger.Info("Starting Miniflux...")
-
-	stop := make(chan os.Signal, 1)
-	signal.Notify(stop, os.Interrupt)
-	signal.Notify(stop, syscall.SIGTERM)
-
-	feedHandler := feed.NewFeedHandler(store)
-	pool := scheduler.NewWorkerPool(feedHandler, cfg.WorkerPoolSize())
-	server := newServer(cfg, store, pool, feedHandler)
-
-	scheduler.NewFeedScheduler(
-		store,
-		pool,
-		cfg.PollingFrequency(),
-		cfg.BatchSize(),
-	)
-
-	scheduler.NewSessionScheduler(store, cfg.SessionCleanupFrequency())
-
-	<-stop
-	logger.Info("Shutting down the server...")
-	ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
-	server.Shutdown(ctx)
-	store.Close()
-	logger.Info("Server gracefully stopped")
-}

daemon/doc.go

@@ -1,10 +0,0 @@
-// Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
-
-/*
-
-Package daemon handles the main application process.
-
-*/
-package daemon

daemon/routes.go

@@ -1,172 +0,0 @@
-// Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package daemon
-
-import (
-	"net/http"
-
-	"github.com/miniflux/miniflux/api"
-	"github.com/miniflux/miniflux/config"
-	"github.com/miniflux/miniflux/fever"
-	"github.com/miniflux/miniflux/http/handler"
-	"github.com/miniflux/miniflux/http/middleware"
-	"github.com/miniflux/miniflux/locale"
-	"github.com/miniflux/miniflux/reader/feed"
-	"github.com/miniflux/miniflux/reader/opml"
-	"github.com/miniflux/miniflux/scheduler"
-	"github.com/miniflux/miniflux/storage"
-	"github.com/miniflux/miniflux/template"
-	"github.com/miniflux/miniflux/ui"
-
-	"github.com/gorilla/mux"
-)
-
-func routes(cfg *config.Config, store *storage.Storage, feedHandler *feed.Handler, pool *scheduler.WorkerPool) *mux.Router {
-	router := mux.NewRouter()
-	translator := locale.Load()
-	templateEngine := template.NewEngine(cfg, router, translator)
-
-	apiController := api.NewController(store, feedHandler)
-	feverController := fever.NewController(store)
-	uiController := ui.NewController(cfg, store, pool, feedHandler, opml.NewHandler(store))
-
-	apiHandler := handler.NewHandler(cfg, store, router, templateEngine, translator, middleware.NewChain(
-		middleware.NewBasicAuthMiddleware(store).Handler,
-	))
-
-	feverHandler := handler.NewHandler(cfg, store, router, templateEngine, translator, middleware.NewChain(
-		middleware.NewFeverMiddleware(store).Handler,
-	))
-
-	uiHandler := handler.NewHandler(cfg, store, router, templateEngine, translator, middleware.NewChain(
-		middleware.NewUserSessionMiddleware(store, router).Handler,
-		middleware.NewSessionMiddleware(cfg, store).Handler,
-	))
-
-	if cfg.BasePath() != "" {
-		router = router.PathPrefix(cfg.BasePath()).Subrouter()
-	}
-
-	router.Handle("/fever/", feverHandler.Use(feverController.Handler)).Name("feverEndpoint")
-
-	router.Handle("/v1/users", apiHandler.Use(apiController.CreateUser)).Methods("POST")
-	router.Handle("/v1/users", apiHandler.Use(apiController.Users)).Methods("GET")
-	router.Handle("/v1/users/{userID:[0-9]+}", apiHandler.Use(apiController.UserByID)).Methods("GET")
-	router.Handle("/v1/users/{userID:[0-9]+}", apiHandler.Use(apiController.UpdateUser)).Methods("PUT")
-	router.Handle("/v1/users/{userID:[0-9]+}", apiHandler.Use(apiController.RemoveUser)).Methods("DELETE")
-	router.Handle("/v1/users/{username}", apiHandler.Use(apiController.UserByUsername)).Methods("GET")
-
-	router.Handle("/v1/categories", apiHandler.Use(apiController.CreateCategory)).Methods("POST")
-	router.Handle("/v1/categories", apiHandler.Use(apiController.GetCategories)).Methods("GET")
-	router.Handle("/v1/categories/{categoryID}", apiHandler.Use(apiController.UpdateCategory)).Methods("PUT")
-	router.Handle("/v1/categories/{categoryID}", apiHandler.Use(apiController.RemoveCategory)).Methods("DELETE")
-
-	router.Handle("/v1/discover", apiHandler.Use(apiController.GetSubscriptions)).Methods("POST")
-
-	router.Handle("/v1/feeds", apiHandler.Use(apiController.CreateFeed)).Methods("POST")
-	router.Handle("/v1/feeds", apiHandler.Use(apiController.GetFeeds)).Methods("Get")
-	router.Handle("/v1/feeds/{feedID}/refresh", apiHandler.Use(apiController.RefreshFeed)).Methods("PUT")
-	router.Handle("/v1/feeds/{feedID}", apiHandler.Use(apiController.GetFeed)).Methods("GET")
-	router.Handle("/v1/feeds/{feedID}", apiHandler.Use(apiController.UpdateFeed)).Methods("PUT")
-	router.Handle("/v1/feeds/{feedID}", apiHandler.Use(apiController.RemoveFeed)).Methods("DELETE")
-	router.Handle("/v1/feeds/{feedID}/icon", apiHandler.Use(apiController.FeedIcon)).Methods("GET")
-	router.Handle("/v1/export", apiHandler.Use(apiController.Export)).Methods("GET")
-
-	router.Handle("/v1/feeds/{feedID}/entries", apiHandler.Use(apiController.GetFeedEntries)).Methods("GET")
-	router.Handle("/v1/feeds/{feedID}/entries/{entryID}", apiHandler.Use(apiController.GetFeedEntry)).Methods("GET")
-	router.Handle("/v1/entries", apiHandler.Use(apiController.GetEntries)).Methods("GET")
-	router.Handle("/v1/entries", apiHandler.Use(apiController.SetEntryStatus)).Methods("PUT")
-	router.Handle("/v1/entries/{entryID}", apiHandler.Use(apiController.GetEntry)).Methods("GET")
-	router.Handle("/v1/entries/{entryID}/bookmark", apiHandler.Use(apiController.ToggleBookmark)).Methods("PUT")
-
-	router.Handle("/stylesheets/{name}.css", uiHandler.Use(uiController.Stylesheet)).Name("stylesheet").Methods("GET")
-	router.Handle("/js", uiHandler.Use(uiController.Javascript)).Name("javascript").Methods("GET")
-	router.Handle("/favicon.ico", uiHandler.Use(uiController.Favicon)).Name("favicon").Methods("GET")
-	router.Handle("/icon/{filename}", uiHandler.Use(uiController.AppIcon)).Name("appIcon").Methods("GET")
-	router.Handle("/manifest.json", uiHandler.Use(uiController.WebManifest)).Name("webManifest").Methods("GET")
-
-	router.Handle("/subscribe", uiHandler.Use(uiController.AddSubscription)).Name("addSubscription").Methods("GET")
-	router.Handle("/subscribe", uiHandler.Use(uiController.SubmitSubscription)).Name("submitSubscription").Methods("POST")
-	router.Handle("/subscriptions", uiHandler.Use(uiController.ChooseSubscription)).Name("chooseSubscription").Methods("POST")
-
-	router.Handle("/mark-all-as-read", uiHandler.Use(uiController.MarkAllAsRead)).Name("markAllAsRead").Methods("GET")
-
-	router.Handle("/unread", uiHandler.Use(uiController.ShowUnreadPage)).Name("unread").Methods("GET")
-	router.Handle("/history", uiHandler.Use(uiController.ShowHistoryPage)).Name("history").Methods("GET")
-	router.Handle("/starred", uiHandler.Use(uiController.ShowStarredPage)).Name("starred").Methods("GET")
-
-	router.Handle("/feed/{feedID}/refresh", uiHandler.Use(uiController.RefreshFeed)).Name("refreshFeed").Methods("GET")
-	router.Handle("/feed/{feedID}/edit", uiHandler.Use(uiController.EditFeed)).Name("editFeed").Methods("GET")
-	router.Handle("/feed/{feedID}/remove", uiHandler.Use(uiController.RemoveFeed)).Name("removeFeed").Methods("POST")
-	router.Handle("/feed/{feedID}/update", uiHandler.Use(uiController.UpdateFeed)).Name("updateFeed").Methods("POST")
-	router.Handle("/feed/{feedID}/entries", uiHandler.Use(uiController.ShowFeedEntries)).Name("feedEntries").Methods("GET")
-	router.Handle("/feeds", uiHandler.Use(uiController.ShowFeedsPage)).Name("feeds").Methods("GET")
-	router.Handle("/feeds/refresh", uiHandler.Use(uiController.RefreshAllFeeds)).Name("refreshAllFeeds").Methods("GET")
-
-	router.Handle("/unread/entry/{entryID}", uiHandler.Use(uiController.ShowUnreadEntry)).Name("unreadEntry").Methods("GET")
-	router.Handle("/history/entry/{entryID}", uiHandler.Use(uiController.ShowReadEntry)).Name("readEntry").Methods("GET")
-	router.Handle("/history/flush", uiHandler.Use(uiController.FlushHistory)).Name("flushHistory").Methods("GET")
-	router.Handle("/feed/{feedID}/entry/{entryID}", uiHandler.Use(uiController.ShowFeedEntry)).Name("feedEntry").Methods("GET")
-	router.Handle("/category/{categoryID}/entry/{entryID}", uiHandler.Use(uiController.ShowCategoryEntry)).Name("categoryEntry").Methods("GET")
-	router.Handle("/starred/entry/{entryID}", uiHandler.Use(uiController.ShowStarredEntry)).Name("starredEntry").Methods("GET")
-
-	router.Handle("/entry/status", uiHandler.Use(uiController.UpdateEntriesStatus)).Name("updateEntriesStatus").Methods("POST")
-	router.Handle("/entry/save/{entryID}", uiHandler.Use(uiController.SaveEntry)).Name("saveEntry").Methods("POST")
-	router.Handle("/entry/download/{entryID}", uiHandler.Use(uiController.FetchContent)).Name("fetchContent").Methods("POST")
-	router.Handle("/entry/bookmark/{entryID}", uiHandler.Use(uiController.ToggleBookmark)).Name("toggleBookmark").Methods("POST")
-
-	router.Handle("/categories", uiHandler.Use(uiController.ShowCategories)).Name("categories").Methods("GET")
-	router.Handle("/category/create", uiHandler.Use(uiController.CreateCategory)).Name("createCategory").Methods("GET")
-	router.Handle("/category/save", uiHandler.Use(uiController.SaveCategory)).Name("saveCategory").Methods("POST")
-	router.Handle("/category/{categoryID}/entries", uiHandler.Use(uiController.ShowCategoryEntries)).Name("categoryEntries").Methods("GET")
-	router.Handle("/category/{categoryID}/edit", uiHandler.Use(uiController.EditCategory)).Name("editCategory").Methods("GET")
-	router.Handle("/category/{categoryID}/update", uiHandler.Use(uiController.UpdateCategory)).Name("updateCategory").Methods("POST")
-	router.Handle("/category/{categoryID}/remove", uiHandler.Use(uiController.RemoveCategory)).Name("removeCategory").Methods("POST")
-
-	router.Handle("/feed/icon/{iconID}", uiHandler.Use(uiController.ShowIcon)).Name("icon").Methods("GET")
-	router.Handle("/proxy/{encodedURL}", uiHandler.Use(uiController.ImageProxy)).Name("proxy").Methods("GET")
-
-	router.Handle("/users", uiHandler.Use(uiController.ShowUsers)).Name("users").Methods("GET")
-	router.Handle("/user/create", uiHandler.Use(uiController.CreateUser)).Name("createUser").Methods("GET")
-	router.Handle("/user/save", uiHandler.Use(uiController.SaveUser)).Name("saveUser").Methods("POST")
-	router.Handle("/users/{userID}/edit", uiHandler.Use(uiController.EditUser)).Name("editUser").Methods("GET")
-	router.Handle("/users/{userID}/update", uiHandler.Use(uiController.UpdateUser)).Name("updateUser").Methods("POST")
-	router.Handle("/users/{userID}/remove", uiHandler.Use(uiController.RemoveUser)).Name("removeUser").Methods("POST")
-
-	router.Handle("/about", uiHandler.Use(uiController.AboutPage)).Name("about").Methods("GET")
-
-	router.Handle("/settings", uiHandler.Use(uiController.ShowSettings)).Name("settings").Methods("GET")
-	router.Handle("/settings", uiHandler.Use(uiController.UpdateSettings)).Name("updateSettings").Methods("POST")
-
-	router.Handle("/bookmarklet", uiHandler.Use(uiController.Bookmarklet)).Name("bookmarklet").Methods("GET")
-	router.Handle("/integrations", uiHandler.Use(uiController.ShowIntegrations)).Name("integrations").Methods("GET")
-	router.Handle("/integration", uiHandler.Use(uiController.UpdateIntegration)).Name("updateIntegration").Methods("POST")
-
-	router.Handle("/sessions", uiHandler.Use(uiController.ShowSessions)).Name("sessions").Methods("GET")
-	router.Handle("/sessions/{sessionID}/remove", uiHandler.Use(uiController.RemoveSession)).Name("removeSession").Methods("POST")
-
-	router.Handle("/export", uiHandler.Use(uiController.Export)).Name("export").Methods("GET")
-	router.Handle("/import", uiHandler.Use(uiController.Import)).Name("import").Methods("GET")
-	router.Handle("/upload", uiHandler.Use(uiController.UploadOPML)).Name("uploadOPML").Methods("POST")
-
-	router.Handle("/oauth2/{provider}/unlink", uiHandler.Use(uiController.OAuth2Unlink)).Name("oauth2Unlink").Methods("GET")
-	router.Handle("/oauth2/{provider}/redirect", uiHandler.Use(uiController.OAuth2Redirect)).Name("oauth2Redirect").Methods("GET")
-	router.Handle("/oauth2/{provider}/callback", uiHandler.Use(uiController.OAuth2Callback)).Name("oauth2Callback").Methods("GET")
-
-	router.Handle("/login", uiHandler.Use(uiController.CheckLogin)).Name("checkLogin").Methods("POST")
-	router.Handle("/logout", uiHandler.Use(uiController.Logout)).Name("logout").Methods("GET")
-	router.Handle("/", uiHandler.Use(uiController.ShowLoginPage)).Name("login").Methods("GET")
-
-	router.HandleFunc("/healthcheck", func(w http.ResponseWriter, r *http.Request) {
-		w.Write([]byte("OK"))
-	})
-
-	router.HandleFunc("/robots.txt", func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "text/plain")
-		w.Write([]byte("User-agent: *\nDisallow: /"))
-	})
-
-	return router
-}

daemon/server.go

@@ -1,70 +0,0 @@
-// Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package daemon
-
-import (
-	"crypto/tls"
-	"net/http"
-	"time"
-
-	"github.com/miniflux/miniflux/config"
-	"github.com/miniflux/miniflux/logger"
-	"github.com/miniflux/miniflux/reader/feed"
-	"github.com/miniflux/miniflux/scheduler"
-	"github.com/miniflux/miniflux/storage"
-
-	"golang.org/x/crypto/acme/autocert"
-)
-
-func newServer(cfg *config.Config, store *storage.Storage, pool *scheduler.WorkerPool, feedHandler *feed.Handler) *http.Server {
-	certFile := cfg.CertFile()
-	keyFile := cfg.KeyFile()
-	certDomain := cfg.CertDomain()
-	certCache := cfg.CertCache()
-	server := &http.Server{
-		ReadTimeout:  5 * time.Second,
-		WriteTimeout: 10 * time.Second,
-		IdleTimeout:  60 * time.Second,
-		Addr:         cfg.ListenAddr(),
-		Handler:      routes(cfg, store, feedHandler, pool),
-	}
-
-	if certDomain != "" && certCache != "" {
-		cfg.IsHTTPS = true
-		server.Addr = ":https"
-		certManager := autocert.Manager{
-			Cache:      autocert.DirCache(certCache),
-			Prompt:     autocert.AcceptTOS,
-			HostPolicy: autocert.HostWhitelist(certDomain),
-		}
-
-		// Handle http-01 challenge.
-		s := &http.Server{
-			Handler: certManager.HTTPHandler(nil),
-			Addr:    ":http",
-		}
-		go s.ListenAndServe()
-
-		go func() {
-			logger.Info(`Listening on "%s" by using auto-configured certificate for "%s"`, server.Addr, certDomain)
-			logger.Fatal(server.Serve(certManager.Listener()).Error())
-		}()
-	} else if certFile != "" && keyFile != "" {
-		server.TLSConfig = &tls.Config{MinVersion: tls.VersionTLS12}
-		cfg.IsHTTPS = true
-
-		go func() {
-			logger.Info(`Listening on "%s" by using certificate "%s" and key "%s"`, server.Addr, certFile, keyFile)
-			logger.Fatal(server.ListenAndServeTLS(certFile, keyFile).Error())
-		}()
-	} else {
-		go func() {
-			logger.Info(`Listening on "%s" without TLS`, server.Addr)
-			logger.Fatal(server.ListenAndServe().Error())
-		}()
-	}
-
-	return server
-}

database/database.go

@@ -0,0 +1,78 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package database // import "miniflux.app/database"
+
+import (
+	"database/sql"
+	"fmt"
+	"time"
+
+	// Postgresql driver import
+	_ "github.com/lib/pq"
+)
+
+// NewConnectionPool configures the database connection pool.
+func NewConnectionPool(dsn string, minConnections, maxConnections int, connectionLifetime time.Duration) (*sql.DB, error) {
+	db, err := sql.Open("postgres", dsn)
+	if err != nil {
+		return nil, err
+	}
+
+	db.SetMaxOpenConns(maxConnections)
+	db.SetMaxIdleConns(minConnections)
+	db.SetConnMaxLifetime(connectionLifetime)
+
+	return db, nil
+}
+
+// Migrate executes database migrations.
+func Migrate(db *sql.DB) error {
+	var currentVersion int
+	db.QueryRow(`SELECT version FROM schema_version`).Scan(&currentVersion)
+
+	fmt.Println("-> Current schema version:", currentVersion)
+	fmt.Println("-> Latest schema version:", schemaVersion)
+
+	for version := currentVersion; version < schemaVersion; version++ {
+		newVersion := version + 1
+		fmt.Println("* Migrating to version:", newVersion)
+
+		tx, err := db.Begin()
+		if err != nil {
+			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
+		}
+
+		if err := migrations[version](tx); err != nil {
+			tx.Rollback()
+			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
+		}
+
+		if _, err := tx.Exec(`DELETE FROM schema_version`); err != nil {
+			tx.Rollback()
+			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
+		}
+
+		if _, err := tx.Exec(`INSERT INTO schema_version (version) VALUES ($1)`, newVersion); err != nil {
+			tx.Rollback()
+			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
+		}
+
+		if err := tx.Commit(); err != nil {
+			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
+		}
+	}
+
+	return nil
+}
+
+// IsSchemaUpToDate checks if the database schema is up to date.
+func IsSchemaUpToDate(db *sql.DB) error {
+	var currentVersion int
+	db.QueryRow(`SELECT version FROM schema_version`).Scan(&currentVersion)
+	if currentVersion < schemaVersion {
+		return fmt.Errorf(`the database schema is not up to date: current=v%d expected=v%d`, currentVersion, schemaVersion)
+	}
+	return nil
+}

database/migrations.go

@@ -0,0 +1,594 @@
+// Copyright 2020 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package database // import "miniflux.app/database"
+
+import (
+	"database/sql"
+)
+
+var schemaVersion = len(migrations)
+
+// Order is important. Add new migrations at the end of the list.
+var migrations = []func(tx *sql.Tx) error{
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE TABLE schema_version (
+				version text not null
+			);
+
+			CREATE TABLE users (
+				id serial not null,
+				username text not null unique,
+				password text,
+				is_admin bool default 'f',
+				language text default 'en_US',
+				timezone text default 'UTC',
+				theme text default 'default',
+				last_login_at timestamp with time zone,
+				primary key (id)
+			);
+
+			CREATE TABLE sessions (
+				id serial not null,
+				user_id int not null,
+				token text not null unique,
+				created_at timestamp with time zone default now(),
+				user_agent text,
+				ip text,
+				primary key (id),
+				unique (user_id, token),
+				foreign key (user_id) references users(id) on delete cascade
+			);
+
+			CREATE TABLE categories (
+				id serial not null,
+				user_id int not null,
+				title text not null,
+				primary key (id),
+				unique (user_id, title),
+				foreign key (user_id) references users(id) on delete cascade
+			);
+
+			CREATE TABLE feeds (
+				id bigserial not null,
+				user_id int not null,
+				category_id int not null,
+				title text not null,
+				feed_url text not null,
+				site_url text not null,
+				checked_at timestamp with time zone default now(),
+				etag_header text default '',
+				last_modified_header text default '',
+				parsing_error_msg text default '',
+				parsing_error_count int default 0,
+				primary key (id),
+				unique (user_id, feed_url),
+				foreign key (user_id) references users(id) on delete cascade,
+				foreign key (category_id) references categories(id) on delete cascade
+			);
+
+			CREATE TYPE entry_status as enum('unread', 'read', 'removed');
+
+			CREATE TABLE entries (
+				id bigserial not null,
+				user_id int not null,
+				feed_id bigint not null,
+				hash text not null,
+				published_at timestamp with time zone not null,
+				title text not null,
+				url text not null,
+				author text,
+				content text,
+				status entry_status default 'unread',
+				primary key (id),
+				unique (feed_id, hash),
+				foreign key (user_id) references users(id) on delete cascade,
+				foreign key (feed_id) references feeds(id) on delete cascade
+			);
+
+			CREATE INDEX entries_feed_idx on entries using btree(feed_id);
+
+			CREATE TABLE enclosures (
+				id bigserial not null,
+				user_id int not null,
+				entry_id bigint not null,
+				url text not null,
+				size int default 0,
+				mime_type text default '',
+				primary key (id),
+				foreign key (user_id) references users(id) on delete cascade,
+				foreign key (entry_id) references entries(id) on delete cascade
+			);
+
+			CREATE TABLE icons (
+				id bigserial not null,
+				hash text not null unique,
+				mime_type text not null,
+				content bytea not null,
+				primary key (id)
+			);
+
+			CREATE TABLE feed_icons (
+				feed_id bigint not null,
+				icon_id bigint not null,
+				primary key(feed_id, icon_id),
+				foreign key (feed_id) references feeds(id) on delete cascade,
+				foreign key (icon_id) references icons(id) on delete cascade
+			);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE EXTENSION IF NOT EXISTS hstore;
+			ALTER TABLE users ADD COLUMN extra hstore;
+			CREATE INDEX users_extra_idx ON users using gin(extra);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE TABLE tokens (
+				id text not null,
+				value text not null,
+				created_at timestamp with time zone not null default now(),
+				primary key(id, value)
+			);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE TYPE entry_sorting_direction AS enum('asc', 'desc');
+			ALTER TABLE users ADD COLUMN entry_direction entry_sorting_direction default 'asc';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE TABLE integrations (
+				user_id int not null,
+				pinboard_enabled bool default 'f',
+				pinboard_token text default '',
+				pinboard_tags text default 'miniflux',
+				pinboard_mark_as_unread bool default 'f',
+				instapaper_enabled bool default 'f',
+				instapaper_username text default '',
+				instapaper_password text default '',
+				fever_enabled bool default 'f',
+				fever_username text default '',
+				fever_password text default '',
+				fever_token text default '',
+				primary key(user_id)
+			);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN scraper_rules text default ''`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN rewrite_rules text default ''`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN crawler boolean default 'f'`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE sessions rename to user_sessions`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			DROP TABLE tokens;
+
+			CREATE TABLE sessions (
+				id text not null,
+				data jsonb not null,
+				created_at timestamp with time zone not null default now(),
+				primary key(id)
+			);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN wallabag_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN wallabag_url text default '';
+			ALTER TABLE integrations ADD COLUMN wallabag_client_id text default '';
+			ALTER TABLE integrations ADD COLUMN wallabag_client_secret text default '';
+			ALTER TABLE integrations ADD COLUMN wallabag_username text default '';
+			ALTER TABLE integrations ADD COLUMN wallabag_password text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE entries ADD COLUMN starred bool default 'f'`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE INDEX entries_user_status_idx ON entries(user_id, status);
+			CREATE INDEX feeds_user_category_idx ON feeds(user_id, category_id);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN nunux_keeper_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN nunux_keeper_url text default '';
+			ALTER TABLE integrations ADD COLUMN nunux_keeper_api_key text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE enclosures ALTER COLUMN size SET DATA TYPE bigint`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE entries ADD COLUMN comments_url text default ''`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN pocket_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN pocket_access_token text default '';
+			ALTER TABLE integrations ADD COLUMN pocket_consumer_key text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE user_sessions ALTER COLUMN ip SET DATA TYPE inet using ip::inet;
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE feeds ADD COLUMN username text default '';
+			ALTER TABLE feeds ADD COLUMN password text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE entries ADD COLUMN document_vectors tsvector;
+			UPDATE entries SET document_vectors = to_tsvector(substring(title || ' ' || coalesce(content, '') for 1000000));
+			CREATE INDEX document_vectors_idx ON entries USING gin(document_vectors);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN user_agent text default ''`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			UPDATE
+				entries
+			SET
+				document_vectors = setweight(to_tsvector(substring(coalesce(title, '') for 1000000)), 'A') || setweight(to_tsvector(substring(coalesce(content, '') for 1000000)), 'B')
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE users ADD COLUMN keyboard_shortcuts boolean default 't'`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN disabled boolean default 'f';`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE users ALTER COLUMN theme SET DEFAULT 'light_serif';
+			UPDATE users SET theme='light_serif' WHERE theme='default';
+			UPDATE users SET theme='light_sans_serif' WHERE theme='sansserif';
+			UPDATE users SET theme='dark_serif' WHERE theme='black';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE entries ADD COLUMN changed_at timestamp with time zone;
+			UPDATE entries SET changed_at = published_at;
+			ALTER TABLE entries ALTER COLUMN changed_at SET not null;
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE TABLE api_keys (
+				id serial not null,
+				user_id int not null references users(id) on delete cascade,
+				token text not null unique,
+				description text not null,
+				last_used_at timestamp with time zone,
+				created_at timestamp with time zone default now(),
+				primary key(id),
+				unique (user_id, description)
+			);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE entries ADD COLUMN share_code text not null default '';
+			CREATE UNIQUE INDEX entries_share_code_idx ON entries USING btree(share_code) WHERE share_code <> '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `CREATE INDEX enclosures_user_entry_url_idx ON enclosures(user_id, entry_id, md5(url))`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE feeds ADD COLUMN next_check_at timestamp with time zone default now();
+			CREATE INDEX entries_user_feed_idx ON entries (user_id, feed_id);
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN ignore_http_cache bool default false`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE users ADD COLUMN entries_per_page int default 100`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE users ADD COLUMN show_reading_time boolean default 't'`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `CREATE INDEX entries_id_user_status_idx ON entries USING btree (id, user_id, status)`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN fetch_via_proxy bool default false`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `CREATE INDEX entries_feed_id_status_hash_idx ON entries USING btree (feed_id, status, hash)`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `CREATE INDEX entries_user_id_status_starred_idx ON entries (user_id, status, starred)`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE users ADD COLUMN entry_swipe boolean default 't'`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE integrations DROP COLUMN fever_password`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE feeds
+				ADD COLUMN blocklist_rules text not null default '',
+				ADD COLUMN keeplist_rules text not null default ''
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE entries ADD COLUMN reading_time int not null default 0`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE entries ADD COLUMN created_at timestamp with time zone not null default now();
+			UPDATE entries SET created_at = published_at;
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		_, err = tx.Exec(`
+			ALTER TABLE users
+				ADD column stylesheet text not null default '',
+				ADD column google_id text not null default '',
+				ADD column openid_connect_id text not null default ''
+		`)
+		if err != nil {
+			return err
+		}
+
+		_, err = tx.Exec(`
+			DECLARE my_cursor CURSOR FOR
+			SELECT
+				id,
+				COALESCE(extra->'custom_css', '') as custom_css,
+				COALESCE(extra->'google_id', '') as google_id,
+				COALESCE(extra->'oidc_id', '') as oidc_id
+			FROM users
+			FOR UPDATE
+		`)
+		if err != nil {
+			return err
+		}
+		defer tx.Exec("CLOSE my_cursor")
+
+		for {
+			var (
+				userID           int64
+				customStylesheet string
+				googleID         string
+				oidcID           string
+			)
+
+			if err := tx.QueryRow(`FETCH NEXT FROM my_cursor`).Scan(&userID, &customStylesheet, &googleID, &oidcID); err != nil {
+				if err == sql.ErrNoRows {
+					break
+				}
+				return err
+			}
+
+			_, err := tx.Exec(
+				`UPDATE
+					users
+				SET
+					stylesheet=$2,
+					google_id=$3,
+					openid_connect_id=$4
+				WHERE
+					id=$1
+				`,
+				userID, customStylesheet, googleID, oidcID)
+			if err != nil {
+				return err
+			}
+		}
+
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		_, err = tx.Exec(`
+			ALTER TABLE users DROP COLUMN extra;
+			CREATE UNIQUE INDEX users_google_id_idx ON users(google_id) WHERE google_id <> '';
+			CREATE UNIQUE INDEX users_openid_connect_id_idx ON users(openid_connect_id) WHERE openid_connect_id <> '';
+		`)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		_, err = tx.Exec(`
+			CREATE INDEX entries_feed_url_idx ON entries(feed_id, url);
+			CREATE INDEX entries_user_status_feed_idx ON entries(user_id, status, feed_id);
+			CREATE INDEX entries_user_status_changed_idx ON entries(user_id, status, changed_at);
+		`)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		_, err = tx.Exec(`
+			CREATE TABLE acme_cache (
+				key varchar(400) not null primary key,
+				data bytea not null,
+				updated_at timestamptz not null
+			);
+		`)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		_, err = tx.Exec(`
+			ALTER TABLE feeds ADD COLUMN allow_self_signed_certificates boolean not null default false
+		`)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE TYPE webapp_display_mode AS enum('fullscreen', 'standalone', 'minimal-ui', 'browser');
+			ALTER TABLE users ADD COLUMN display_mode webapp_display_mode default 'standalone';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN cookie text default ''`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		_, err = tx.Exec(`
+			ALTER TABLE categories ADD COLUMN hide_globally boolean not null default false
+		`)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		_, err = tx.Exec(`
+			ALTER TABLE feeds ADD COLUMN hide_globally boolean not null default false
+		`)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN telegram_bot_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN telegram_bot_token text default '';
+			ALTER TABLE integrations ADD COLUMN telegram_bot_chat_id text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			CREATE TYPE entry_sorting_order AS enum('published_at', 'created_at');
+			ALTER TABLE users ADD COLUMN entry_order entry_sorting_order default 'published_at';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN googlereader_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN googlereader_username text default '';
+			ALTER TABLE integrations ADD COLUMN googlereader_password text default '';
+			`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN espial_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN espial_url text default '';
+			ALTER TABLE integrations ADD COLUMN espial_api_key text default '';
+			ALTER TABLE integrations ADD COLUMN espial_tags text default 'miniflux';
+			`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN linkding_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN linkding_url text default '';
+			ALTER TABLE integrations ADD COLUMN linkding_api_key text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+}

doc.go

@@ -1,10 +1,10 @@
 // Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
 
 /*
 
-Package main implements a feed reader application.
+Miniflux is a feed reader application.
 
 */
-package main
+package main // import "miniflux.app"

errors/doc.go

@@ -1,10 +1,10 @@
 // Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
 
 /*
 
 Package errors handles localized errors.
 
 */
-package errors
+package errors // import "miniflux.app/errors"

errors/errors.go

@@ -2,12 +2,12 @@
 // Use of this source code is governed by the Apache 2.0
 // license that can be found in the LICENSE file.
 
-package errors
+package errors // import "miniflux.app/errors"
 
 import (
 	"fmt"
 
-	"github.com/miniflux/miniflux/locale"
+	"miniflux.app/locale"
 )
 
 // LocalizedError represents an error than could be translated to another language.
@@ -22,11 +22,11 @@ func (l LocalizedError) Error() string {
 }
 
 // Localize returns the translated error message.
-func (l LocalizedError) Localize(translation *locale.Language) string {
-	return translation.Get(l.message, l.args...)
+func (l LocalizedError) Localize(printer *locale.Printer) string {
+	return printer.Printf(l.message, l.args...)
 }
 
 // NewLocalizedError returns a new LocalizedError.
-func NewLocalizedError(message string, args ...interface{}) LocalizedError {
-	return LocalizedError{message: message, args: args}
+func NewLocalizedError(message string, args ...interface{}) *LocalizedError {
+	return &LocalizedError{message: message, args: args}
 }

fever/doc.go

@@ -1,10 +1,10 @@
 // Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
 
 /*
 
 Package fever implements Fever API endpoints.
 
 */
-package fever
+package fever // import "miniflux.app/fever"

fever/fever.go

@@ -1,631 +0,0 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package fever
-
-import (
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/miniflux/miniflux/http/handler"
-	"github.com/miniflux/miniflux/integration"
-	"github.com/miniflux/miniflux/logger"
-	"github.com/miniflux/miniflux/model"
-	"github.com/miniflux/miniflux/storage"
-)
-
-type baseResponse struct {
-	Version       int   `json:"api_version"`
-	Authenticated int   `json:"auth"`
-	LastRefresh   int64 `json:"last_refreshed_on_time"`
-}
-
-func (b *baseResponse) SetCommonValues() {
-	b.Version = 3
-	b.Authenticated = 1
-	b.LastRefresh = time.Now().Unix()
-}
-
-/*
-The default response is a JSON object containing two members:
-
-    api_version contains the version of the API responding (positive integer)
-    auth whether the request was successfully authenticated (boolean integer)
-
-The API can also return XML by passing xml as the optional value of the api argument like so:
-
-http://yourdomain.com/fever/?api=xml
-
-The top level XML element is named response.
-
-The response to each successfully authenticated request will have auth set to 1 and include
-at least one additional member:
-
-	last_refreshed_on_time contains the time of the most recently refreshed (not updated)
-	feed (Unix timestamp/integer)
-
-*/
-func newBaseResponse() baseResponse {
-	r := baseResponse{}
-	r.SetCommonValues()
-	return r
-}
-
-type groupsResponse struct {
-	baseResponse
-	Groups      []group       `json:"groups"`
-	FeedsGroups []feedsGroups `json:"feeds_groups"`
-}
-
-type feedsResponse struct {
-	baseResponse
-	Feeds       []feed        `json:"feeds"`
-	FeedsGroups []feedsGroups `json:"feeds_groups"`
-}
-
-type faviconsResponse struct {
-	baseResponse
-	Favicons []favicon `json:"favicons"`
-}
-
-type itemsResponse struct {
-	baseResponse
-	Items []item `json:"items"`
-	Total int    `json:"total_items"`
-}
-
-type unreadResponse struct {
-	baseResponse
-	ItemIDs string `json:"unread_item_ids"`
-}
-
-type savedResponse struct {
-	baseResponse
-	ItemIDs string `json:"saved_item_ids"`
-}
-
-type group struct {
-	ID    int64  `json:"id"`
-	Title string `json:"title"`
-}
-
-type feedsGroups struct {
-	GroupID int64  `json:"group_id"`
-	FeedIDs string `json:"feed_ids"`
-}
-
-type feed struct {
-	ID          int64  `json:"id"`
-	FaviconID   int64  `json:"favicon_id"`
-	Title       string `json:"title"`
-	URL         string `json:"url"`
-	SiteURL     string `json:"site_url"`
-	IsSpark     int    `json:"is_spark"`
-	LastUpdated int64  `json:"last_updated_on_time"`
-}
-
-type item struct {
-	ID        int64  `json:"id"`
-	FeedID    int64  `json:"feed_id"`
-	Title     string `json:"title"`
-	Author    string `json:"author"`
-	HTML      string `json:"html"`
-	URL       string `json:"url"`
-	IsSaved   int    `json:"is_saved"`
-	IsRead    int    `json:"is_read"`
-	CreatedAt int64  `json:"created_on_time"`
-}
-
-type favicon struct {
-	ID   int64  `json:"id"`
-	Data string `json:"data"`
-}
-
-// Controller implements the Fever API.
-type Controller struct {
-	store *storage.Storage
-}
-
-// Handler handles Fever API calls
-func (c *Controller) Handler(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	switch {
-	case request.HasQueryParam("groups"):
-		c.handleGroups(ctx, request, response)
-	case request.HasQueryParam("feeds"):
-		c.handleFeeds(ctx, request, response)
-	case request.HasQueryParam("favicons"):
-		c.handleFavicons(ctx, request, response)
-	case request.HasQueryParam("unread_item_ids"):
-		c.handleUnreadItems(ctx, request, response)
-	case request.HasQueryParam("saved_item_ids"):
-		c.handleSavedItems(ctx, request, response)
-	case request.HasQueryParam("items"):
-		c.handleItems(ctx, request, response)
-	case request.FormValue("mark") == "item":
-		c.handleWriteItems(ctx, request, response)
-	case request.FormValue("mark") == "feed":
-		c.handleWriteFeeds(ctx, request, response)
-	case request.FormValue("mark") == "group":
-		c.handleWriteGroups(ctx, request, response)
-	default:
-		response.JSON().Standard(newBaseResponse())
-	}
-}
-
-/*
-A request with the groups argument will return two additional members:
-
-    groups contains an array of group objects
-    feeds_groups contains an array of feeds_group objects
-
-A group object has the following members:
-
-    id (positive integer)
-    title (utf-8 string)
-
-The feeds_group object is documented under “Feeds/Groups Relationships.”
-
-The “Kindling” super group is not included in this response and is composed of all feeds with
-an is_spark equal to 0.
-
-The “Sparks” super group is not included in this response and is composed of all feeds with an
-is_spark equal to 1.
-
-*/
-func (c *Controller) handleGroups(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Fetching groups for userID=%d", userID)
-
-	categories, err := c.store.Categories(userID)
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	feeds, err := c.store.Feeds(userID)
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	var result groupsResponse
-	for _, category := range categories {
-		result.Groups = append(result.Groups, group{ID: category.ID, Title: category.Title})
-	}
-
-	result.FeedsGroups = c.buildFeedGroups(feeds)
-	result.SetCommonValues()
-	response.JSON().Standard(result)
-}
-
-/*
-A request with the feeds argument will return two additional members:
-
-    feeds contains an array of group objects
-    feeds_groups contains an array of feeds_group objects
-
-A feed object has the following members:
-
-    id (positive integer)
-    favicon_id (positive integer)
-    title (utf-8 string)
-    url (utf-8 string)
-    site_url (utf-8 string)
-    is_spark (boolean integer)
-    last_updated_on_time (Unix timestamp/integer)
-
-The feeds_group object is documented under “Feeds/Groups Relationships.”
-
-The “All Items” super feed is not included in this response and is composed of all items from all feeds
-that belong to a given group. For the “Kindling” super group and all user created groups the items
-should be limited to feeds with an is_spark equal to 0.
-
-For the “Sparks” super group the items should be limited to feeds with an is_spark equal to 1.
-*/
-func (c *Controller) handleFeeds(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Fetching feeds for userID=%d", userID)
-
-	feeds, err := c.store.Feeds(userID)
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	var result feedsResponse
-	result.Feeds = make([]feed, 0)
-	for _, f := range feeds {
-		subscripion := feed{
-			ID:          f.ID,
-			Title:       f.Title,
-			URL:         f.FeedURL,
-			SiteURL:     f.SiteURL,
-			IsSpark:     0,
-			LastUpdated: f.CheckedAt.Unix(),
-		}
-
-		if f.Icon != nil {
-			subscripion.FaviconID = f.Icon.IconID
-		}
-
-		result.Feeds = append(result.Feeds, subscripion)
-	}
-
-	result.FeedsGroups = c.buildFeedGroups(feeds)
-	result.SetCommonValues()
-	response.JSON().Standard(result)
-}
-
-/*
-A request with the favicons argument will return one additional member:
-
-    favicons contains an array of favicon objects
-
-A favicon object has the following members:
-
-    id (positive integer)
-    data (base64 encoded image data; prefixed by image type)
-
-An example data value:
-
-	image/gif;base64,R0lGODlhAQABAIAAAObm5gAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==
-
-The data member of a favicon object can be used with the data: protocol to embed an image in CSS or HTML.
-A PHP/HTML example:
-
-	echo '<img src="data:'.$favicon['data'].'">';
-*/
-func (c *Controller) handleFavicons(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Fetching favicons for userID=%d", userID)
-
-	icons, err := c.store.Icons(userID)
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	var result faviconsResponse
-	for _, i := range icons {
-		result.Favicons = append(result.Favicons, favicon{
-			ID:   i.ID,
-			Data: i.DataURL(),
-		})
-	}
-
-	result.SetCommonValues()
-	response.JSON().Standard(result)
-}
-
-/*
-A request with the items argument will return two additional members:
-
-    items contains an array of item objects
-    total_items contains the total number of items stored in the database (added in API version 2)
-
-An item object has the following members:
-
-    id (positive integer)
-    feed_id (positive integer)
-    title (utf-8 string)
-    author (utf-8 string)
-    html (utf-8 string)
-    url (utf-8 string)
-    is_saved (boolean integer)
-    is_read (boolean integer)
-    created_on_time (Unix timestamp/integer)
-
-Most servers won’t have enough memory allocated to PHP to dump all items at once.
-Three optional arguments control determine the items included in the response.
-
-	Use the since_id argument with the highest id of locally cached items to request 50 additional items.
-	Repeat until the items array in the response is empty.
-
-	Use the max_id argument with the lowest id of locally cached items (or 0 initially) to request 50 previous items.
-	Repeat until the items array in the response is empty. (added in API version 2)
-
-	Use the with_ids argument with a comma-separated list of item ids to request (a maximum of 50) specific items.
-	(added in API version 2)
-
-*/
-func (c *Controller) handleItems(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	var result itemsResponse
-
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Fetching items for userID=%d", userID)
-
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithoutStatus(model.EntryStatusRemoved)
-	builder.WithLimit(50)
-	builder.WithOrder("id")
-	builder.WithDirection(model.DefaultSortingDirection)
-
-	sinceID := request.QueryIntegerParam("since_id", 0)
-	if sinceID > 0 {
-		builder.WithGreaterThanEntryID(int64(sinceID))
-	}
-
-	maxID := request.QueryIntegerParam("max_id", 0)
-	if maxID > 0 {
-		builder.WithOffset(maxID)
-	}
-
-	csvItemIDs := request.QueryStringParam("with_ids", "")
-	if csvItemIDs != "" {
-		var itemIDs []int64
-
-		for _, strItemID := range strings.Split(csvItemIDs, ",") {
-			strItemID = strings.TrimSpace(strItemID)
-			itemID, _ := strconv.Atoi(strItemID)
-			itemIDs = append(itemIDs, int64(itemID))
-		}
-
-		builder.WithEntryIDs(itemIDs)
-	}
-
-	entries, err := builder.GetEntries()
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	builder = c.store.NewEntryQueryBuilder(userID)
-	builder.WithoutStatus(model.EntryStatusRemoved)
-	result.Total, err = builder.CountEntries()
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	for _, entry := range entries {
-		isRead := 0
-		if entry.Status == model.EntryStatusRead {
-			isRead = 1
-		}
-
-		isSaved := 0
-		if entry.Starred {
-			isSaved = 1
-		}
-
-		result.Items = append(result.Items, item{
-			ID:        entry.ID,
-			FeedID:    entry.FeedID,
-			Title:     entry.Title,
-			Author:    entry.Author,
-			HTML:      entry.Content,
-			URL:       entry.URL,
-			IsSaved:   isSaved,
-			IsRead:    isRead,
-			CreatedAt: entry.Date.Unix(),
-		})
-	}
-
-	result.SetCommonValues()
-	response.JSON().Standard(result)
-}
-
-/*
-The unread_item_ids and saved_item_ids arguments can be used to keep your local cache synced
-with the remote Fever installation.
-
-A request with the unread_item_ids argument will return one additional member:
-    unread_item_ids (string/comma-separated list of positive integers)
-*/
-func (c *Controller) handleUnreadItems(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Fetching unread items for userID=%d", userID)
-
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithStatus(model.EntryStatusUnread)
-	entries, err := builder.GetEntries()
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	var itemIDs []string
-	for _, entry := range entries {
-		itemIDs = append(itemIDs, strconv.FormatInt(entry.ID, 10))
-	}
-
-	var result unreadResponse
-	result.ItemIDs = strings.Join(itemIDs, ",")
-	result.SetCommonValues()
-	response.JSON().Standard(result)
-}
-
-/*
-The unread_item_ids and saved_item_ids arguments can be used to keep your local cache synced
-with the remote Fever installation.
-
-	A request with the saved_item_ids argument will return one additional member:
-
-	saved_item_ids (string/comma-separated list of positive integers)
-*/
-func (c *Controller) handleSavedItems(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Fetching saved items for userID=%d", userID)
-
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithStarred()
-
-	entryIDs, err := builder.GetEntryIDs()
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	var itemsIDs []string
-	for _, entryID := range entryIDs {
-		itemsIDs = append(itemsIDs, strconv.FormatInt(entryID, 10))
-	}
-
-	result := &savedResponse{ItemIDs: strings.Join(itemsIDs, ",")}
-	result.SetCommonValues()
-	response.JSON().Standard(result)
-}
-
-/*
-	mark=item
-	as=? where ? is replaced with read, saved or unsaved
-	id=? where ? is replaced with the id of the item to modify
-*/
-func (c *Controller) handleWriteItems(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Receiving mark=item call for userID=%d", userID)
-
-	entryID := request.FormIntegerValue("id")
-	if entryID <= 0 {
-		return
-	}
-
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithEntryID(entryID)
-	builder.WithoutStatus(model.EntryStatusRemoved)
-
-	entry, err := builder.GetEntry()
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	if entry == nil {
-		return
-	}
-
-	switch request.FormValue("as") {
-	case "read":
-		c.store.SetEntriesStatus(userID, []int64{entryID}, model.EntryStatusRead)
-	case "unread":
-		c.store.SetEntriesStatus(userID, []int64{entryID}, model.EntryStatusUnread)
-	case "saved", "unsaved":
-		if err := c.store.ToggleBookmark(userID, entryID); err != nil {
-			response.JSON().ServerError(err)
-			return
-		}
-
-		settings, err := c.store.Integration(userID)
-		if err != nil {
-			response.JSON().ServerError(err)
-			return
-		}
-
-		go func() {
-			integration.SendEntry(entry, settings)
-		}()
-	}
-
-	response.JSON().Standard(newBaseResponse())
-}
-
-/*
-	mark=? where ? is replaced with feed or group
-	as=read
-	id=? where ? is replaced with the id of the feed or group to modify
-	before=? where ? is replaced with the Unix timestamp of the the local client’s most recent items API request
-*/
-func (c *Controller) handleWriteFeeds(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Receiving mark=feed call for userID=%d", userID)
-
-	feedID := request.FormIntegerValue("id")
-	if feedID <= 0 {
-		return
-	}
-
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithStatus(model.EntryStatusUnread)
-	builder.WithFeedID(feedID)
-
-	before := request.FormIntegerValue("before")
-	if before > 0 {
-		t := time.Unix(before, 0)
-		builder.Before(&t)
-	}
-
-	entryIDs, err := builder.GetEntryIDs()
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	err = c.store.SetEntriesStatus(userID, entryIDs, model.EntryStatusRead)
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	response.JSON().Standard(newBaseResponse())
-}
-
-/*
-	mark=? where ? is replaced with feed or group
-	as=read
-	id=? where ? is replaced with the id of the feed or group to modify
-	before=? where ? is replaced with the Unix timestamp of the the local client’s most recent items API request
-*/
-func (c *Controller) handleWriteGroups(ctx *handler.Context, request *handler.Request, response *handler.Response) {
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Receiving mark=group call for userID=%d", userID)
-
-	groupID := request.FormIntegerValue("id")
-	if groupID < 0 {
-		return
-	}
-
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithStatus(model.EntryStatusUnread)
-	builder.WithCategoryID(groupID)
-
-	before := request.FormIntegerValue("before")
-	if before > 0 {
-		t := time.Unix(before, 0)
-		builder.Before(&t)
-	}
-
-	entryIDs, err := builder.GetEntryIDs()
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	err = c.store.SetEntriesStatus(userID, entryIDs, model.EntryStatusRead)
-	if err != nil {
-		response.JSON().ServerError(err)
-		return
-	}
-
-	response.JSON().Standard(newBaseResponse())
-}
-
-/*
-A feeds_group object has the following members:
-
-    group_id (positive integer)
-    feed_ids (string/comma-separated list of positive integers)
-
-*/
-func (c *Controller) buildFeedGroups(feeds model.Feeds) []feedsGroups {
-	feedsGroupedByCategory := make(map[int64][]string)
-	for _, feed := range feeds {
-		feedsGroupedByCategory[feed.Category.ID] = append(feedsGroupedByCategory[feed.Category.ID], strconv.FormatInt(feed.ID, 10))
-	}
-
-	result := make([]feedsGroups, 0)
-	for categoryID, feedIDs := range feedsGroupedByCategory {
-		result = append(result, feedsGroups{
-			GroupID: categoryID,
-			FeedIDs: strings.Join(feedIDs, ","),
-		})
-	}
-
-	return result
-}
-
-// NewController returns a new Fever API.
-func NewController(store *storage.Storage) *Controller {
-	return &Controller{store: store}
-}

fever/handler.go

@@ -0,0 +1,532 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package fever // import "miniflux.app/fever"
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/integration"
+	"miniflux.app/logger"
+	"miniflux.app/model"
+	"miniflux.app/storage"
+
+	"github.com/gorilla/mux"
+)
+
+// Serve handles Fever API calls.
+func Serve(router *mux.Router, store *storage.Storage) {
+	handler := &handler{store}
+
+	sr := router.PathPrefix("/fever").Subrouter()
+	sr.Use(newMiddleware(store).serve)
+	sr.HandleFunc("/", handler.serve).Name("feverEndpoint")
+}
+
+type handler struct {
+	store *storage.Storage
+}
+
+func (h *handler) serve(w http.ResponseWriter, r *http.Request) {
+	switch {
+	case request.HasQueryParam(r, "groups"):
+		h.handleGroups(w, r)
+	case request.HasQueryParam(r, "feeds"):
+		h.handleFeeds(w, r)
+	case request.HasQueryParam(r, "favicons"):
+		h.handleFavicons(w, r)
+	case request.HasQueryParam(r, "unread_item_ids"):
+		h.handleUnreadItems(w, r)
+	case request.HasQueryParam(r, "saved_item_ids"):
+		h.handleSavedItems(w, r)
+	case request.HasQueryParam(r, "items"):
+		h.handleItems(w, r)
+	case r.FormValue("mark") == "item":
+		h.handleWriteItems(w, r)
+	case r.FormValue("mark") == "feed":
+		h.handleWriteFeeds(w, r)
+	case r.FormValue("mark") == "group":
+		h.handleWriteGroups(w, r)
+	default:
+		json.OK(w, r, newBaseResponse())
+	}
+}
+
+/*
+A request with the groups argument will return two additional members:
+
+    groups contains an array of group objects
+    feeds_groups contains an array of feeds_group objects
+
+A group object has the following members:
+
+    id (positive integer)
+    title (utf-8 string)
+
+The feeds_group object is documented under “Feeds/Groups Relationships.”
+
+The “Kindling” super group is not included in this response and is composed of all feeds with
+an is_spark equal to 0.
+
+The “Sparks” super group is not included in this response and is composed of all feeds with an
+is_spark equal to 1.
+
+*/
+func (h *handler) handleGroups(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	logger.Debug("[Fever] Fetching groups for user #%d", userID)
+
+	categories, err := h.store.Categories(userID)
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	feeds, err := h.store.Feeds(userID)
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	var result groupsResponse
+	for _, category := range categories {
+		result.Groups = append(result.Groups, group{ID: category.ID, Title: category.Title})
+	}
+
+	result.FeedsGroups = h.buildFeedGroups(feeds)
+	result.SetCommonValues()
+	json.OK(w, r, result)
+}
+
+/*
+A request with the feeds argument will return two additional members:
+
+    feeds contains an array of group objects
+    feeds_groups contains an array of feeds_group objects
+
+A feed object has the following members:
+
+    id (positive integer)
+    favicon_id (positive integer)
+    title (utf-8 string)
+    url (utf-8 string)
+    site_url (utf-8 string)
+    is_spark (boolean integer)
+    last_updated_on_time (Unix timestamp/integer)
+
+The feeds_group object is documented under “Feeds/Groups Relationships.”
+
+The “All Items” super feed is not included in this response and is composed of all items from all feeds
+that belong to a given group. For the “Kindling” super group and all user created groups the items
+should be limited to feeds with an is_spark equal to 0.
+
+For the “Sparks” super group the items should be limited to feeds with an is_spark equal to 1.
+*/
+func (h *handler) handleFeeds(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	logger.Debug("[Fever] Fetching feeds for userID=%d", userID)
+
+	feeds, err := h.store.Feeds(userID)
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	var result feedsResponse
+	result.Feeds = make([]feed, 0)
+	for _, f := range feeds {
+		subscripion := feed{
+			ID:          f.ID,
+			Title:       f.Title,
+			URL:         f.FeedURL,
+			SiteURL:     f.SiteURL,
+			IsSpark:     0,
+			LastUpdated: f.CheckedAt.Unix(),
+		}
+
+		if f.Icon != nil {
+			subscripion.FaviconID = f.Icon.IconID
+		}
+
+		result.Feeds = append(result.Feeds, subscripion)
+	}
+
+	result.FeedsGroups = h.buildFeedGroups(feeds)
+	result.SetCommonValues()
+	json.OK(w, r, result)
+}
+
+/*
+A request with the favicons argument will return one additional member:
+
+    favicons contains an array of favicon objects
+
+A favicon object has the following members:
+
+    id (positive integer)
+    data (base64 encoded image data; prefixed by image type)
+
+An example data value:
+
+	image/gif;base64,R0lGODlhAQABAIAAAObm5gAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==
+
+The data member of a favicon object can be used with the data: protocol to embed an image in CSS or HTML.
+A PHP/HTML example:
+
+	echo '<img src="data:'.$favicon['data'].'">';
+*/
+func (h *handler) handleFavicons(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	logger.Debug("[Fever] Fetching favicons for user #%d", userID)
+
+	icons, err := h.store.Icons(userID)
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	var result faviconsResponse
+	for _, i := range icons {
+		result.Favicons = append(result.Favicons, favicon{
+			ID:   i.ID,
+			Data: i.DataURL(),
+		})
+	}
+
+	result.SetCommonValues()
+	json.OK(w, r, result)
+}
+
+/*
+A request with the items argument will return two additional members:
+
+    items contains an array of item objects
+    total_items contains the total number of items stored in the database (added in API version 2)
+
+An item object has the following members:
+
+    id (positive integer)
+    feed_id (positive integer)
+    title (utf-8 string)
+    author (utf-8 string)
+    html (utf-8 string)
+    url (utf-8 string)
+    is_saved (boolean integer)
+    is_read (boolean integer)
+    created_on_time (Unix timestamp/integer)
+
+Most servers won’t have enough memory allocated to PHP to dump all items at once.
+Three optional arguments control determine the items included in the response.
+
+	Use the since_id argument with the highest id of locally cached items to request 50 additional items.
+	Repeat until the items array in the response is empty.
+
+	Use the max_id argument with the lowest id of locally cached items (or 0 initially) to request 50 previous items.
+	Repeat until the items array in the response is empty. (added in API version 2)
+
+	Use the with_ids argument with a comma-separated list of item ids to request (a maximum of 50) specific items.
+	(added in API version 2)
+
+*/
+func (h *handler) handleItems(w http.ResponseWriter, r *http.Request) {
+	var result itemsResponse
+
+	userID := request.UserID(r)
+
+	builder := h.store.NewEntryQueryBuilder(userID)
+	builder.WithoutStatus(model.EntryStatusRemoved)
+	builder.WithLimit(50)
+	builder.WithOrder("id")
+	builder.WithDirection(model.DefaultSortingDirection)
+
+	switch {
+	case request.HasQueryParam(r, "since_id"):
+		sinceID := request.QueryInt64Param(r, "since_id", 0)
+		if sinceID > 0 {
+			logger.Debug("[Fever] Fetching items since #%d for user #%d", sinceID, userID)
+			builder.AfterEntryID(sinceID)
+		}
+	case request.HasQueryParam(r, "max_id"):
+		maxID := request.QueryInt64Param(r, "max_id", 0)
+		if maxID == 0 {
+			logger.Debug("[Fever] Fetching most recent items for user #%d", userID)
+			builder.WithDirection("desc")
+		} else if maxID > 0 {
+			logger.Debug("[Fever] Fetching items before #%d for user #%d", maxID, userID)
+			builder.BeforeEntryID(maxID)
+			builder.WithDirection("desc")
+		}
+	case request.HasQueryParam(r, "with_ids"):
+		csvItemIDs := request.QueryStringParam(r, "with_ids", "")
+		if csvItemIDs != "" {
+			var itemIDs []int64
+
+			for _, strItemID := range strings.Split(csvItemIDs, ",") {
+				strItemID = strings.TrimSpace(strItemID)
+				itemID, _ := strconv.ParseInt(strItemID, 10, 64)
+				itemIDs = append(itemIDs, itemID)
+			}
+
+			builder.WithEntryIDs(itemIDs)
+		}
+	default:
+		logger.Debug("[Fever] Fetching oldest items for user #%d", userID)
+	}
+
+	entries, err := builder.GetEntries()
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	builder = h.store.NewEntryQueryBuilder(userID)
+	builder.WithoutStatus(model.EntryStatusRemoved)
+	result.Total, err = builder.CountEntries()
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	result.Items = make([]item, 0)
+	for _, entry := range entries {
+		isRead := 0
+		if entry.Status == model.EntryStatusRead {
+			isRead = 1
+		}
+
+		isSaved := 0
+		if entry.Starred {
+			isSaved = 1
+		}
+
+		result.Items = append(result.Items, item{
+			ID:        entry.ID,
+			FeedID:    entry.FeedID,
+			Title:     entry.Title,
+			Author:    entry.Author,
+			HTML:      entry.Content,
+			URL:       entry.URL,
+			IsSaved:   isSaved,
+			IsRead:    isRead,
+			CreatedAt: entry.Date.Unix(),
+		})
+	}
+
+	result.SetCommonValues()
+	json.OK(w, r, result)
+}
+
+/*
+The unread_item_ids and saved_item_ids arguments can be used to keep your local cache synced
+with the remote Fever installation.
+
+A request with the unread_item_ids argument will return one additional member:
+    unread_item_ids (string/comma-separated list of positive integers)
+*/
+func (h *handler) handleUnreadItems(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	logger.Debug("[Fever] Fetching unread items for user #%d", userID)
+
+	builder := h.store.NewEntryQueryBuilder(userID)
+	builder.WithStatus(model.EntryStatusUnread)
+	rawEntryIDs, err := builder.GetEntryIDs()
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	var itemIDs []string
+	for _, entryID := range rawEntryIDs {
+		itemIDs = append(itemIDs, strconv.FormatInt(entryID, 10))
+	}
+
+	var result unreadResponse
+	result.ItemIDs = strings.Join(itemIDs, ",")
+	result.SetCommonValues()
+	json.OK(w, r, result)
+}
+
+/*
+The unread_item_ids and saved_item_ids arguments can be used to keep your local cache synced
+with the remote Fever installation.
+
+	A request with the saved_item_ids argument will return one additional member:
+
+	saved_item_ids (string/comma-separated list of positive integers)
+*/
+func (h *handler) handleSavedItems(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	logger.Debug("[Fever] Fetching saved items for user #%d", userID)
+
+	builder := h.store.NewEntryQueryBuilder(userID)
+	builder.WithStarred(true)
+
+	entryIDs, err := builder.GetEntryIDs()
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	var itemsIDs []string
+	for _, entryID := range entryIDs {
+		itemsIDs = append(itemsIDs, strconv.FormatInt(entryID, 10))
+	}
+
+	result := &savedResponse{ItemIDs: strings.Join(itemsIDs, ",")}
+	result.SetCommonValues()
+	json.OK(w, r, result)
+}
+
+/*
+	mark=item
+	as=? where ? is replaced with read, saved or unsaved
+	id=? where ? is replaced with the id of the item to modify
+*/
+func (h *handler) handleWriteItems(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	logger.Debug("[Fever] Receiving mark=item call for user #%d", userID)
+
+	entryID := request.FormInt64Value(r, "id")
+	if entryID <= 0 {
+		return
+	}
+
+	builder := h.store.NewEntryQueryBuilder(userID)
+	builder.WithEntryID(entryID)
+	builder.WithoutStatus(model.EntryStatusRemoved)
+
+	entry, err := builder.GetEntry()
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	if entry == nil {
+		logger.Debug("[Fever] Marking entry #%d but not found, ignored", entryID)
+		json.OK(w, r, newBaseResponse())
+		return
+	}
+
+	switch r.FormValue("as") {
+	case "read":
+		logger.Debug("[Fever] Mark entry #%d as read for user #%d", entryID, userID)
+		h.store.SetEntriesStatus(userID, []int64{entryID}, model.EntryStatusRead)
+	case "unread":
+		logger.Debug("[Fever] Mark entry #%d as unread for user #%d", entryID, userID)
+		h.store.SetEntriesStatus(userID, []int64{entryID}, model.EntryStatusUnread)
+	case "saved":
+		logger.Debug("[Fever] Mark entry #%d as saved for user #%d", entryID, userID)
+		if err := h.store.ToggleBookmark(userID, entryID); err != nil {
+			json.ServerError(w, r, err)
+			return
+		}
+
+		settings, err := h.store.Integration(userID)
+		if err != nil {
+			json.ServerError(w, r, err)
+			return
+		}
+
+		go func() {
+			integration.SendEntry(entry, settings)
+		}()
+	case "unsaved":
+		logger.Debug("[Fever] Mark entry #%d as unsaved for user #%d", entryID, userID)
+		if err := h.store.ToggleBookmark(userID, entryID); err != nil {
+			json.ServerError(w, r, err)
+			return
+		}
+	}
+
+	json.OK(w, r, newBaseResponse())
+}
+
+/*
+	mark=feed
+	as=read
+	id=? where ? is replaced with the id of the feed or group to modify
+	before=? where ? is replaced with the Unix timestamp of the the local client’s most recent items API request
+*/
+func (h *handler) handleWriteFeeds(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	feedID := request.FormInt64Value(r, "id")
+	before := time.Unix(request.FormInt64Value(r, "before"), 0)
+
+	logger.Debug("[Fever] Mark feed #%d as read for user #%d before %v", feedID, userID, before)
+
+	if feedID <= 0 {
+		return
+	}
+
+	go func() {
+		if err := h.store.MarkFeedAsRead(userID, feedID, before); err != nil {
+			logger.Error("[Fever] MarkFeedAsRead failed: %v", err)
+		}
+	}()
+
+	json.OK(w, r, newBaseResponse())
+}
+
+/*
+	mark=group
+	as=read
+	id=? where ? is replaced with the id of the feed or group to modify
+	before=? where ? is replaced with the Unix timestamp of the the local client’s most recent items API request
+*/
+func (h *handler) handleWriteGroups(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	groupID := request.FormInt64Value(r, "id")
+	before := time.Unix(request.FormInt64Value(r, "before"), 0)
+
+	logger.Debug("[Fever] Mark group #%d as read for user #%d before %v", groupID, userID, before)
+
+	if groupID < 0 {
+		return
+	}
+
+	go func() {
+		var err error
+
+		if groupID == 0 {
+			err = h.store.MarkAllAsRead(userID)
+		} else {
+			err = h.store.MarkCategoryAsRead(userID, groupID, before)
+		}
+
+		if err != nil {
+			logger.Error("[Fever] MarkCategoryAsRead failed: %v", err)
+		}
+	}()
+
+	json.OK(w, r, newBaseResponse())
+}
+
+/*
+A feeds_group object has the following members:
+
+    group_id (positive integer)
+    feed_ids (string/comma-separated list of positive integers)
+
+*/
+func (h *handler) buildFeedGroups(feeds model.Feeds) []feedsGroups {
+	feedsGroupedByCategory := make(map[int64][]string)
+	for _, feed := range feeds {
+		feedsGroupedByCategory[feed.Category.ID] = append(feedsGroupedByCategory[feed.Category.ID], strconv.FormatInt(feed.ID, 10))
+	}
+
+	result := make([]feedsGroups, 0)
+	for categoryID, feedIDs := range feedsGroupedByCategory {
+		result = append(result, feedsGroups{
+			GroupID: categoryID,
+			FeedIDs: strings.Join(feedIDs, ","),
+		})
+	}
+
+	return result
+}

fever/middleware.go

@@ -0,0 +1,59 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package fever // import "miniflux.app/fever"
+
+import (
+	"context"
+	"net/http"
+
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/logger"
+	"miniflux.app/storage"
+)
+
+type middleware struct {
+	store *storage.Storage
+}
+
+func newMiddleware(s *storage.Storage) *middleware {
+	return &middleware{s}
+}
+
+func (m *middleware) serve(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		clientIP := request.ClientIP(r)
+		apiKey := r.FormValue("api_key")
+		if apiKey == "" {
+			logger.Info("[Fever] [ClientIP=%s] No API key provided", clientIP)
+			json.OK(w, r, newAuthFailureResponse())
+			return
+		}
+
+		user, err := m.store.UserByFeverToken(apiKey)
+		if err != nil {
+			logger.Error("[Fever] %v", err)
+			json.OK(w, r, newAuthFailureResponse())
+			return
+		}
+
+		if user == nil {
+			logger.Info("[Fever] [ClientIP=%s] No user found with this API key", clientIP)
+			json.OK(w, r, newAuthFailureResponse())
+			return
+		}
+
+		logger.Info("[Fever] [ClientIP=%s] User #%d is authenticated with user agent %q", clientIP, user.ID, r.UserAgent())
+		m.store.SetLastLogin(user.ID)
+
+		ctx := r.Context()
+		ctx = context.WithValue(ctx, request.UserIDContextKey, user.ID)
+		ctx = context.WithValue(ctx, request.UserTimezoneContextKey, user.Timezone)
+		ctx = context.WithValue(ctx, request.IsAdminUserContextKey, user.IsAdmin)
+		ctx = context.WithValue(ctx, request.IsAuthenticatedContextKey, true)
+
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

fever/response.go

@@ -0,0 +1,120 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package fever // import "miniflux.app/fever"
+
+import (
+	"time"
+)
+
+type baseResponse struct {
+	Version       int   `json:"api_version"`
+	Authenticated int   `json:"auth"`
+	LastRefresh   int64 `json:"last_refreshed_on_time"`
+}
+
+func (b *baseResponse) SetCommonValues() {
+	b.Version = 3
+	b.Authenticated = 1
+	b.LastRefresh = time.Now().Unix()
+}
+
+/*
+The default response is a JSON object containing two members:
+
+    api_version contains the version of the API responding (positive integer)
+    auth whether the request was successfully authenticated (boolean integer)
+
+The API can also return XML by passing xml as the optional value of the api argument like so:
+
+http://yourdomain.com/fever/?api=xml
+
+The top level XML element is named response.
+
+The response to each successfully authenticated request will have auth set to 1 and include
+at least one additional member:
+
+	last_refreshed_on_time contains the time of the most recently refreshed (not updated)
+	feed (Unix timestamp/integer)
+
+*/
+func newBaseResponse() baseResponse {
+	r := baseResponse{}
+	r.SetCommonValues()
+	return r
+}
+
+func newAuthFailureResponse() baseResponse {
+	return baseResponse{Version: 3, Authenticated: 0}
+}
+
+type groupsResponse struct {
+	baseResponse
+	Groups      []group       `json:"groups"`
+	FeedsGroups []feedsGroups `json:"feeds_groups"`
+}
+
+type feedsResponse struct {
+	baseResponse
+	Feeds       []feed        `json:"feeds"`
+	FeedsGroups []feedsGroups `json:"feeds_groups"`
+}
+
+type faviconsResponse struct {
+	baseResponse
+	Favicons []favicon `json:"favicons"`
+}
+
+type itemsResponse struct {
+	baseResponse
+	Items []item `json:"items"`
+	Total int    `json:"total_items"`
+}
+
+type unreadResponse struct {
+	baseResponse
+	ItemIDs string `json:"unread_item_ids"`
+}
+
+type savedResponse struct {
+	baseResponse
+	ItemIDs string `json:"saved_item_ids"`
+}
+
+type group struct {
+	ID    int64  `json:"id"`
+	Title string `json:"title"`
+}
+
+type feedsGroups struct {
+	GroupID int64  `json:"group_id"`
+	FeedIDs string `json:"feed_ids"`
+}
+
+type feed struct {
+	ID          int64  `json:"id"`
+	FaviconID   int64  `json:"favicon_id"`
+	Title       string `json:"title"`
+	URL         string `json:"url"`
+	SiteURL     string `json:"site_url"`
+	IsSpark     int    `json:"is_spark"`
+	LastUpdated int64  `json:"last_updated_on_time"`
+}
+
+type item struct {
+	ID        int64  `json:"id"`
+	FeedID    int64  `json:"feed_id"`
+	Title     string `json:"title"`
+	Author    string `json:"author"`
+	HTML      string `json:"html"`
+	URL       string `json:"url"`
+	IsSaved   int    `json:"is_saved"`
+	IsRead    int    `json:"is_read"`
+	CreatedAt int64  `json:"created_on_time"`
+}
+
+type favicon struct {
+	ID   int64  `json:"id"`
+	Data string `json:"data"`
+}

filter/doc.go

@@ -1,10 +0,0 @@
-// Copyright 2018 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the MIT license
-// that can be found in the LICENSE file.
-
-/*
-
-Package filter implements a content filter to rewrite image links.
-
-*/
-package filter

filter/image_proxy_filter.go

@@ -1,41 +0,0 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package filter
-
-import (
-	"encoding/base64"
-	"strings"
-
-	"github.com/miniflux/miniflux/http/route"
-	"github.com/miniflux/miniflux/url"
-
-	"github.com/PuerkitoBio/goquery"
-	"github.com/gorilla/mux"
-)
-
-// ImageProxyFilter rewrites image tag URLs without HTTPS to local proxy URL
-func ImageProxyFilter(router *mux.Router, data string) string {
-	doc, err := goquery.NewDocumentFromReader(strings.NewReader(data))
-	if err != nil {
-		return data
-	}
-
-	doc.Find("img").Each(func(i int, img *goquery.Selection) {
-		if srcAttr, ok := img.Attr("src"); ok {
-			if !url.IsHTTPS(srcAttr) {
-				img.SetAttr("src", Proxify(router, srcAttr))
-			}
-		}
-	})
-
-	output, _ := doc.Find("body").First().Html()
-	return output
-}
-
-// Proxify returns a proxified link.
-func Proxify(router *mux.Router, link string) string {
-	// We use base64 url encoding to avoid slash in the URL.
-	return route.Path(router, "proxy", "encodedURL", base64.URLEncoding.EncodeToString([]byte(link)))
-}

filter/image_proxy_filter_test.go

@@ -1,38 +0,0 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package filter
-
-import (
-	"net/http"
-	"testing"
-
-	"github.com/gorilla/mux"
-)
-
-func TestProxyFilterWithHttp(t *testing.T) {
-	r := mux.NewRouter()
-	r.HandleFunc("/proxy/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
-
-	input := `<p><img src="http://website/folder/image.png" alt="Test"/></p>`
-	output := ImageProxyFilter(r, input)
-	expected := `<p><img src="/proxy/aHR0cDovL3dlYnNpdGUvZm9sZGVyL2ltYWdlLnBuZw==" alt="Test"/></p>`
-
-	if expected != output {
-		t.Errorf(`Not expected output: got "%s" instead of "%s"`, output, expected)
-	}
-}
-
-func TestProxyFilterWithHttps(t *testing.T) {
-	r := mux.NewRouter()
-	r.HandleFunc("/proxy/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
-
-	input := `<p><img src="https://website/folder/image.png" alt="Test"/></p>`
-	output := ImageProxyFilter(r, input)
-	expected := `<p><img src="https://website/folder/image.png" alt="Test"/></p>`
-
-	if expected != output {
-		t.Errorf(`Not expected output: got "%s" instead of "%s"`, output, expected)
-	}
-}

generate.go

@@ -1,120 +0,0 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-package main
-
-import (
-	"crypto/sha256"
-	"encoding/base64"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-	"text/template"
-	"time"
-
-	"github.com/tdewolff/minify"
-	"github.com/tdewolff/minify/css"
-	"github.com/tdewolff/minify/js"
-)
-
-const tpl = `// Code generated by go generate; DO NOT EDIT.
-// {{ .Timestamp }}
-
-package {{ .Package }}
-
-var {{ .Map }} = map[string]string{
-{{ range $constant, $content := .Files }}` + "\t" + `"{{ $constant }}": ` + "`{{ $content }}`" + `,
-{{ end }}}
-
-var {{ .Map }}Checksums = map[string]string{
-{{ range $constant, $content := .Checksums }}` + "\t" + `"{{ $constant }}": "{{ $content }}",
-{{ end }}}
-`
-
-var generatedTpl = template.Must(template.New("").Parse(tpl))
-
-type GeneratedFile struct {
-	Package, Map string
-	Timestamp    time.Time
-	Files        map[string]string
-	Checksums    map[string]string
-}
-
-func normalizeBasename(filename string) string {
-	filename = strings.TrimSuffix(filename, filepath.Ext(filename))
-	return strings.Replace(filename, " ", "_", -1)
-}
-
-func generateFile(serializer, pkg, mapName, pattern, output string) {
-	generatedFile := &GeneratedFile{
-		Package:   pkg,
-		Map:       mapName,
-		Timestamp: time.Now(),
-		Files:     make(map[string]string),
-		Checksums: make(map[string]string),
-	}
-
-	files, _ := filepath.Glob(pattern)
-	for _, file := range files {
-		basename := path.Base(file)
-		content, err := ioutil.ReadFile(file)
-		if err != nil {
-			panic(err)
-		}
-
-		switch serializer {
-		case "css":
-			m := minify.New()
-			m.AddFunc("text/css", css.Minify)
-			content, err = m.Bytes("text/css", content)
-			if err != nil {
-				panic(err)
-			}
-
-			basename = normalizeBasename(basename)
-			generatedFile.Files[basename] = string(content)
-		case "js":
-			m := minify.New()
-			m.AddFunc("text/javascript", js.Minify)
-			content, err = m.Bytes("text/javascript", content)
-			if err != nil {
-				panic(err)
-			}
-
-			basename = normalizeBasename(basename)
-			generatedFile.Files[basename] = string(content)
-		case "base64":
-			encodedContent := base64.StdEncoding.EncodeToString(content)
-			generatedFile.Files[basename] = encodedContent
-		default:
-			basename = normalizeBasename(basename)
-			generatedFile.Files[basename] = string(content)
-		}
-
-		generatedFile.Checksums[basename] = fmt.Sprintf("%x", sha256.Sum256(content))
-	}
-
-	f, err := os.Create(output)
-	if err != nil {
-		panic(err)
-	}
-	defer f.Close()
-
-	generatedTpl.Execute(f, generatedFile)
-}
-
-func main() {
-	generateFile("none", "sql", "SqlMap", "sql/*.sql", "sql/sql.go")
-	generateFile("base64", "static", "Binaries", "ui/static/bin/*", "ui/static/bin.go")
-	generateFile("css", "static", "Stylesheets", "ui/static/css/*.css", "ui/static/css.go")
-	generateFile("js", "static", "Javascript", "ui/static/js/*.js", "ui/static/js.go")
-	generateFile("none", "template", "templateViewsMap", "template/html/*.html", "template/views.go")
-	generateFile("none", "template", "templateCommonMap", "template/html/common/*.html", "template/common.go")
-	generateFile("none", "locale", "translations", "locale/translations/*.json", "locale/translations.go")
-}

go.mod

@@ -0,0 +1,27 @@
+module miniflux.app
+
+// +heroku goVersion go1.16
+
+require (
+	github.com/PuerkitoBio/goquery v1.8.0
+	github.com/coreos/go-oidc v2.2.1+incompatible
+	github.com/felixge/httpsnoop v1.0.1 // indirect
+	github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible
+	github.com/golang/gddo v0.0.0-20200831202555-721e228c7686 // indirect
+	github.com/gorilla/mux v1.8.0
+	github.com/lib/pq v1.10.6
+	github.com/mitchellh/go-server-timing v1.0.2-0.20201108055052-feb680ab92c2
+	github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35 // indirect
+	github.com/prometheus/client_golang v1.12.2
+	github.com/rylans/getlang v0.0.0-20200505200108-4c3188ff8a2d
+	github.com/stretchr/testify v1.6.1 // indirect
+	github.com/tdewolff/minify/v2 v2.11.5
+	github.com/technoweenie/multipartstreamer v1.0.1 // indirect
+	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
+	golang.org/x/net v0.0.0-20210916014120-12bc252f5db8
+	golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c
+	gopkg.in/square/go-jose.v2 v2.5.0 // indirect
+	mvdan.cc/xurls/v2 v2.4.0
+)
+
+go 1.16

go.sum

@@ -0,0 +1,640 @@
+cloud.google.com/go v0.16.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
+cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/PuerkitoBio/goquery v1.8.0 h1:PJTF7AmFCFKk1N6V6jmKfrNH9tV5pNE6lZMkG0gta/U=
+github.com/PuerkitoBio/goquery v1.8.0/go.mod h1:ypIiRMtY7COPGk+I/YbZLbxsxn9g5ejnI2HSMtkjZvI=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/andybalholm/cascadia v1.3.1 h1:nhxRkql1kdYCc8Snf7D5/D3spOX+dBgjA6u8x004T2c=
+github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bradfitz/gomemcache v0.0.0-20170208213004-1952afaa557d/go.mod h1:PmM6Mmwb0LSuEubjR8N7PtNe1KxZLtOUHtbeikc5h60=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927/go.mod h1:h/aW8ynjgkuj+NQRlZcDbAbM1ORAbXjXX77sX7T289U=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/coreos/go-oidc v2.2.1+incompatible h1:mh48q/BqXqgjVHpy2ZY7WnWAbenxRjsz9N1i1YxjHAk=
+github.com/coreos/go-oidc v2.2.1+incompatible/go.mod h1:CgnwVTmzoESiwO9qyAFEMiHoZ1nMCKZlZ9V6mm3/LKc=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/cosiner/argv v0.1.0/go.mod h1:EusR6TucWKX+zFgtdUsKT2Cvg45K5rtpCcWz4hK06d8=
+github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
+github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
+github.com/djherbis/atime v1.1.0/go.mod h1:28OF6Y8s3NQWwacXc5eZTsEsiMzp7LF8MbXE+XJPdBE=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/felixge/httpsnoop v1.0.0/go.mod h1:3+D9sFq0ahK/JeJPhCBUV1xlf4/eIYrUQaxulT0VzX8=
+github.com/felixge/httpsnoop v1.0.1 h1:lvB5Jl89CsZtGIWuTcDM1E/vkVs49/Ml7JJe07l8SPQ=
+github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/fsnotify/fsnotify v1.4.3-0.20170329110642-4da3e2cfbabc/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.5.3/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU=
+github.com/garyburd/redigo v1.1.1-0.20170914051019-70e1b1943d4f/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/go-delve/delve v1.5.0/go.mod h1:c6b3a1Gry6x8a4LGCe/CWzrocrfaHvkUxCj3k4bvSUQ=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
+github.com/go-stack/stack v1.6.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible h1:2cauKuaELYAEARXRkq2LrJ0yDDv1rW7+wrTEdVL3uaU=
+github.com/go-telegram-bot-api/telegram-bot-api v4.6.4+incompatible/go.mod h1:qf9acutJ8cwBUhm1bqgz6Bei9/C/c93FPDljKWwsOgM=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/golang/gddo v0.0.0-20180823221919-9d8ff1c67be5/go.mod h1:xEhNfoBDX1hzLm2Nf80qUvZ2sVwoMZ8d6IE2SrsQfh4=
+github.com/golang/gddo v0.0.0-20200831202555-721e228c7686 h1:5vu7C+63KTbsSNnLhrgB98Sqy8MNVSW8FdhkcWA/3Rk=
+github.com/golang/gddo v0.0.0-20200831202555-721e228c7686/go.mod h1:sam69Hju0uq+5uvLJUMDlsKlQ21Vrs1Kd/1YFPNYdOU=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/lint v0.0.0-20170918230701-e5d664eb928e/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw=
+github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/snappy v0.0.0-20170215233205-553a64147049/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.1.1-0.20171103154506-982329095285/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-dap v0.2.0/go.mod h1:5q8aYQFnHOAZEMP+6vmq25HKYAEwE+LF5yh7JKrrhSQ=
+github.com/google/go-dap v0.3.0/go.mod h1:5q8aYQFnHOAZEMP+6vmq25HKYAEwE+LF5yh7JKrrhSQ=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
+github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/gregjones/httpcache v0.0.0-20170920190843-316c5e0ff04e/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hashicorp/hcl v0.0.0-20170914154624-68e816d1c783/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/inconshreveable/log15 v0.0.0-20170622235902-74a0988b5f80/go.mod h1:cOaXtrgN4ScfRrD9Bre7U1thNq5RtJ8ZoP4iXVGRj6o=
+github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
+github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/lib/pq v1.10.6 h1:jbk+ZieJ0D7EVGJYpL9QTz7/YW6UHbmdnZWYyK5cdBs=
+github.com/lib/pq v1.10.6/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/magiconair/properties v1.7.4-0.20170902060319-8d7837e64d3c/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/matryer/try v0.0.0-20161228173917-9ac251b645a2/go.mod h1:0KeJpeMD6o+O4hW7qJOT7vyQPKrWmj26uf5wMc/IiIs=
+github.com/mattn/go-colorable v0.0.0-20170327083344-ded68f7a9561/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-colorable v0.0.10-0.20170816031813-ad5389df28cd/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.2/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-server-timing v1.0.2-0.20201108055052-feb680ab92c2 h1:9kYRAm87/M5VL+HWegDGIorBWDiErrZrksLKTJBF2IQ=
+github.com/mitchellh/go-server-timing v1.0.2-0.20201108055052-feb680ab92c2/go.mod h1:8mKJVJkyMI20ifXXO0zlV3sh3FrtjvltAeBqz38clBE=
+github.com/mitchellh/mapstructure v0.0.0-20170523030023-d0303fe80992/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
+github.com/pelletier/go-toml v1.0.1-0.20170904195809-1d6b12b7cb29/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/peterh/liner v0.0.0-20170317030525-88609521dc4b/go.mod h1:xIteQHvHuaLYG9IFj6mSxM0fCKrs34IrEQUhOYuGPHc=
+github.com/peterh/liner v1.2.0/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35 h1:J9b7z+QKAmPf4YLrFg6oQUotqHQeUNWwkvo7jZp1GLU=
+github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35/go.mod h1:prYjPmNq4d1NPVmpShWobRqXY3q7Vp+80DqgxxUrUIA=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
+github.com/prometheus/client_golang v1.11.0/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
+github.com/prometheus/client_golang v1.12.2 h1:51L9cDoUHVrXx4zWYlcLQIZ+d+VXHgqnYKkIuq4g/34=
+github.com/prometheus/client_golang v1.12.2/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
+github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
+github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4=
+github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU=
+github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
+github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
+github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/rylans/getlang v0.0.0-20200505200108-4c3188ff8a2d h1:4Jn2kzSKcpxxwpJdyWxfNWKCYe4Uki2VibkExYmBLiA=
+github.com/rylans/getlang v0.0.0-20200505200108-4c3188ff8a2d/go.mod h1:3vfmZI6aJd5Rb9W2TQ0Nmupl+qem21R05+hmCscI0Bk=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
+github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
+github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v0.0.0-20170901052352-ee1bd8ee15a1/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/cast v1.1.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.0-20170417170307-b6cb39589372/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
+github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
+github.com/spf13/jwalterweatherman v0.0.0-20170901151539-12bd96e66386/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v0.0.0-20170417173400-9e4c21054fa1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.1-0.20170901120850-7aff26db30c1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.0.0/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
+github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/tdewolff/minify/v2 v2.11.5 h1:wfRJ6JMmu87Azx+Lj7NcCTg8D/L/92SNuYF5fv31fjg=
+github.com/tdewolff/minify/v2 v2.11.5/go.mod h1:ZR6VK7tbgF0XXBVwDHXrbqM4tGYchBpdwhsbKeDmAww=
+github.com/tdewolff/parse/v2 v2.5.31 h1:PrJN/trWTUYaYxg7jRpKnKXpBK4kBjT9rAFhFAh2Lus=
+github.com/tdewolff/parse/v2 v2.5.31/go.mod h1:WzaJpRSbwq++EIQHYIRTpbYKNA3gn9it1Ik++q4zyho=
+github.com/tdewolff/test v1.0.6 h1:76mzYJQ83Op284kMT+63iCNCI7NEERsIN8dLM+RiKr4=
+github.com/tdewolff/test v1.0.6/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+github.com/technoweenie/multipartstreamer v1.0.1 h1:XRztA5MXiR1TIRHxH2uNxXxaIkKQDeX7m2XsSOlQEnM=
+github.com/technoweenie/multipartstreamer v1.0.1/go.mod h1:jNVxdtShOxzAsukZwTSw6MDx5eUJoiEBsSvzDU9uzog=
+github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
+github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.starlark.net v0.0.0-20190702223751-32f345186213/go.mod h1:c1/X6cHgvdXj6pUlmWKMkuqRnW4K8x2vwt6JAaaircg=
+go.starlark.net v0.0.0-20201006213952-227f4aabceb5/go.mod h1:f0znQkUKRrkk36XxWbGjMqQM8wGv/xHBVE2qc3B5oFU=
+go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+golang.org/x/arch v0.0.0-20190927153633-4e8777c89be4/go.mod h1:flIaEI6LNU6xOCD5PaJvn9wGP0agmIOqjrtsKGRguv4=
+golang.org/x/arch v0.0.0-20201008161808-52c3e6f60cff/go.mod h1:flIaEI6LNU6xOCD5PaJvn9wGP0agmIOqjrtsKGRguv4=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20210916014120-12bc252f5db8 h1:/6y1LfuqNuQdHAm0jjtPtgRcxIxjVZgm5OTu8/QhZvk=
+golang.org/x/net v0.0.0-20210916014120-12bc252f5db8/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/oauth2 v0.0.0-20170912212905-13449ad91cb2/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c h1:pkQiBZBvdos9qq4wBAHqlzuZHEXo07pqV06ef90u1WI=
+golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/sync v0.0.0-20170517211232-f52d1811a629/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0=
+golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/time v0.0.0-20170424234030-8be79e1e0910/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191127201027-ecd32218bd7f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/api v0.0.0-20170921000349-586095a6e407/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
+google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6 h1:lMO5rYAqUxkmaj76jAkRUvt5JZgFymx/+Q5Mzfivuhc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20170918111702-1e559d0a00ee/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/grpc v1.2.1-0.20170921194603-d4b75ebd4f9f/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=
+google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+gopkg.in/square/go-jose.v2 v2.5.0 h1:OZ4sdq+Y+SHfYB7vfthi1Ei8b0vkP8ZPQgUfUwdUSqo=
+gopkg.in/square/go-jose.v2 v2.5.0/go.mod h1:M9dMgbHiYLoDGQrXy7OpJDJWiKiU//h+vD76mk0e1AI=
+gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+mvdan.cc/xurls/v2 v2.4.0 h1:tzxjVAj+wSBmDcF6zBB7/myTy3gX9xvi8Tyr28AuQgc=
+mvdan.cc/xurls/v2 v2.4.0/go.mod h1:+GEjq9uNjqs8LQfM9nVnM8rff0OQ5Iash5rzX+N1CSg=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=

googlereader/doc.go

@@ -0,0 +1,10 @@
+// Copyright 2022 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+/*
+
+Package googlereader implements Google Reader API endpoints.
+
+*/
+package googlereader // import "miniflux.app/googlereader"

googlereader/middleware.go

@@ -0,0 +1,208 @@
+// Copyright 2022 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package googlereader // import "miniflux.app/googlereader"
+
+import (
+	"context"
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/hex"
+	"net/http"
+	"strings"
+
+	"miniflux.app/http/request"
+	"miniflux.app/http/response"
+	"miniflux.app/http/response/json"
+	"miniflux.app/logger"
+	"miniflux.app/model"
+	"miniflux.app/storage"
+)
+
+type middleware struct {
+	store *storage.Storage
+}
+
+func newMiddleware(s *storage.Storage) *middleware {
+	return &middleware{s}
+}
+
+func (m *middleware) clientLogin(w http.ResponseWriter, r *http.Request) {
+	clientIP := request.ClientIP(r)
+	var username, password, output string
+	var integration *model.Integration
+	err := r.ParseForm()
+	if err != nil {
+		logger.Error("[GoogleReader][Login] [ClientIP=%s] Could not parse form", clientIP)
+		json.Unauthorized(w, r)
+		return
+	}
+	username = r.Form.Get("Email")
+	password = r.Form.Get("Passwd")
+	output = r.Form.Get("output")
+
+	if username == "" || password == "" {
+		logger.Error("[GoogleReader][Login] [ClientIP=%s] Empty username or password", clientIP)
+		json.Unauthorized(w, r)
+		return
+	}
+
+	if err = m.store.GoogleReaderUserCheckPassword(username, password); err != nil {
+		logger.Error("[GoogleReader][Login] [ClientIP=%s] Invalid username or password: %s", clientIP, username)
+		json.Unauthorized(w, r)
+		return
+	}
+
+	logger.Info("[GoogleReader][Login] [ClientIP=%s] User authenticated: %s", clientIP, username)
+
+	if integration, err = m.store.GoogleReaderUserGetIntegration(username); err != nil {
+		logger.Error("[GoogleReader][Login] [ClientIP=%s] Could not load integration: %s", clientIP, username)
+		json.Unauthorized(w, r)
+		return
+	}
+
+	m.store.SetLastLogin(integration.UserID)
+
+	token := getAuthToken(integration.GoogleReaderUsername, integration.GoogleReaderPassword)
+	logger.Info("[GoogleReader][Login] [ClientIP=%s] Created token: %s", clientIP, token)
+	result := login{SID: token, LSID: token, Auth: token}
+	if output == "json" {
+		json.OK(w, r, result)
+		return
+	}
+	builder := response.New(w, r)
+	builder.WithHeader("Content-Type", "text/plain; charset=UTF-8")
+	builder.WithBody(result.String())
+	builder.Write()
+}
+
+func (m *middleware) token(w http.ResponseWriter, r *http.Request) {
+	clientIP := request.ClientIP(r)
+
+	if !request.IsAuthenticated(r) {
+		logger.Error("[GoogleReader][Token] [ClientIP=%s] User is not authenticated", clientIP)
+		json.Unauthorized(w, r)
+		return
+	}
+	token := request.GoolgeReaderToken(r)
+	if token == "" {
+		logger.Error("[GoogleReader][Token] [ClientIP=%s] User does not have token: %s", clientIP, request.UserID(r))
+		json.Unauthorized(w, r)
+		return
+	}
+	logger.Info("[GoogleReader][Token] [ClientIP=%s] token: %s", clientIP, token)
+	w.Header().Add("Content-Type", "text/plain; charset=UTF-8")
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte(token))
+}
+
+func (m *middleware) handleCORS(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		w.Header().Set("Access-Control-Allow-Headers", "Authorization")
+		if r.Method == http.MethodOptions {
+			w.WriteHeader(http.StatusOK)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		clientIP := request.ClientIP(r)
+
+		var token string
+		if r.Method == http.MethodPost {
+			err := r.ParseForm()
+			if err != nil {
+				logger.Error("[GoogleReader][Login] [ClientIP=%s] Could not parse form", clientIP)
+				Unauthorized(w, r)
+				return
+			}
+			token = r.Form.Get("T")
+			if token == "" {
+				logger.Error("[GoogleReader][Auth] [ClientIP=%s] Post-Form T field is empty", clientIP)
+				Unauthorized(w, r)
+				return
+			}
+		} else {
+			authorization := r.Header.Get("Authorization")
+
+			if authorization == "" {
+				logger.Error("[GoogleReader][Auth] [ClientIP=%s] No token provided", clientIP)
+				Unauthorized(w, r)
+				return
+			}
+			fields := strings.Fields(authorization)
+			if len(fields) != 2 {
+				logger.Error("[GoogleReader][Auth] [ClientIP=%s] Authorization header does not have the expected structure GoogleLogin auth=xxxxxx - '%s'", clientIP, authorization)
+				Unauthorized(w, r)
+				return
+			}
+			if fields[0] != "GoogleLogin" {
+				logger.Error("[GoogleReader][Auth] [ClientIP=%s] Authorization header does not begin with GoogleLogin - '%s'", clientIP, authorization)
+				Unauthorized(w, r)
+				return
+			}
+			auths := strings.Split(fields[1], "=")
+			if len(auths) != 2 {
+				logger.Error("[GoogleReader][Auth] [ClientIP=%s] Authorization header does not have the expected structure GoogleLogin auth=xxxxxx - '%s'", clientIP, authorization)
+				Unauthorized(w, r)
+				return
+			}
+			if auths[0] != "auth" {
+				logger.Error("[GoogleReader][Auth] [ClientIP=%s] Authorization header does not have the expected structure GoogleLogin auth=xxxxxx - '%s'", clientIP, authorization)
+				Unauthorized(w, r)
+				return
+			}
+			token = auths[1]
+		}
+
+		parts := strings.Split(token, "/")
+		if len(parts) != 2 {
+			logger.Error("[GoogleReader][Auth] [ClientIP=%s] Auth token does not have the expected structure username/hash - '%s'", clientIP, token)
+			Unauthorized(w, r)
+			return
+		}
+		var integration *model.Integration
+		var user *model.User
+		var err error
+		if integration, err = m.store.GoogleReaderUserGetIntegration(parts[0]); err != nil {
+			logger.Error("[GoogleReader][Auth] [ClientIP=%s] token: %s", clientIP, token)
+			logger.Error("[GoogleReader][Auth] [ClientIP=%s] No user found with the given google reader username: %s", clientIP, parts[0])
+			Unauthorized(w, r)
+			return
+		}
+		expectedToken := getAuthToken(integration.GoogleReaderUsername, integration.GoogleReaderPassword)
+		if expectedToken != token {
+			logger.Error("[GoogleReader][Auth] [ClientIP=%s] Token does not match: %s", clientIP, token)
+			Unauthorized(w, r)
+			return
+		}
+		if user, err = m.store.UserByID(integration.UserID); err != nil {
+			logger.Error("[GoogleReader][Auth] [ClientIP=%s] No user found with the userID: %d", clientIP, integration.UserID)
+			Unauthorized(w, r)
+			return
+		}
+
+		m.store.SetLastLogin(integration.UserID)
+
+		ctx := r.Context()
+		ctx = context.WithValue(ctx, request.UserIDContextKey, user.ID)
+		ctx = context.WithValue(ctx, request.UserTimezoneContextKey, user.Timezone)
+		ctx = context.WithValue(ctx, request.IsAdminUserContextKey, user.IsAdmin)
+		ctx = context.WithValue(ctx, request.IsAuthenticatedContextKey, true)
+		ctx = context.WithValue(ctx, request.GoogleReaderToken, token)
+
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func getAuthToken(username, password string) string {
+	token := hex.EncodeToString(hmac.New(sha1.New, []byte(username+password)).Sum(nil))
+	token = username + "/" + token
+	return token
+}

googlereader/response.go

@@ -0,0 +1,144 @@
+// Copyright 2022 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package googlereader // import "miniflux.app/googlereader"
+
+import (
+	"fmt"
+	"net/http"
+
+	"miniflux.app/http/response"
+	"miniflux.app/logger"
+)
+
+type login struct {
+	SID  string `json:"SID,omitempty"`
+	LSID string `json:"LSID,omitempty"`
+	Auth string `json:"Auth,omitempty"`
+}
+
+func (l login) String() string {
+	return fmt.Sprintf("SID=%s\nLSID=%s\nAuth=%s\n", l.SID, l.LSID, l.Auth)
+}
+
+type userInfo struct {
+	UserID        string `json:"userId"`
+	UserName      string `json:"userName"`
+	UserProfileID string `json:"userProfileId"`
+	UserEmail     string `json:"userEmail"`
+}
+
+type subscription struct {
+	ID         string                 `json:"id"`
+	Title      string                 `json:"title"`
+	Categories []subscriptionCategory `json:"categories"`
+	URL        string                 `json:"url"`
+	HTMLURL    string                 `json:"htmlUrl"`
+	IconURL    string                 `json:"iconUrl"`
+}
+
+type quickAddResponse struct {
+	NumResults int64  `json:"numResults"`
+	Query      string `json:"query,omitempty"`
+	StreamID   string `json:"streamId,omitempty"`
+	StreamName string `json:"streamName,omitempty"`
+}
+
+type subscriptionCategory struct {
+	ID    string `json:"id"`
+	Label string `json:"label,omitempty"`
+	Type  string `json:"type,omitempty"`
+}
+type subscriptionsResponse struct {
+	Subscriptions []subscription `json:"subscriptions"`
+}
+
+type itemRef struct {
+	ID              string `json:"id"`
+	DirectStreamIDs string `json:"directStreamIds,omitempty"`
+	TimestampUsec   string `json:"timestampUsec,omitempty"`
+}
+
+type streamIDResponse struct {
+	ItemRefs []itemRef `json:"itemRefs"`
+}
+
+type tagsResponse struct {
+	Tags []subscriptionCategory `json:"tags"`
+}
+
+type streamContentItems struct {
+	Direction string            `json:"direction"`
+	ID        string            `json:"id"`
+	Title     string            `json:"title"`
+	Self      []contentHREF     `json:"self"`
+	Alternate []contentHREFType `json:"alternate"`
+	Updated   int64             `json:"updated"`
+	Items     []contentItem     `json:"items"`
+	Author    string            `json:"author"`
+}
+
+type contentItem struct {
+	ID            string                 `json:"id"`
+	Categories    []string               `json:"categories"`
+	Title         string                 `json:"title"`
+	CrawlTimeMsec string                 `json:"crawlTimeMsec"`
+	TimestampUsec string                 `json:"timestampUsec"`
+	Published     int64                  `json:"published"`
+	Updated       int64                  `json:"updated"`
+	Author        string                 `json:"author"`
+	Alternate     []contentHREFType      `json:"alternate"`
+	Summary       contentItemContent     `json:"summary"`
+	Content       contentItemContent     `json:"content"`
+	Origin        contentItemOrigin      `json:"origin"`
+	Enclosure     []contentItemEnclosure `json:"enclosure"`
+	Canonical     []contentHREF          `json:"canonical"`
+}
+
+type contentHREFType struct {
+	HREF string `json:"href"`
+	Type string `json:"type"`
+}
+
+type contentHREF struct {
+	HREF string `json:"href"`
+}
+
+type contentItemEnclosure struct {
+	URL  string `json:"url"`
+	Type string `json:"type"`
+}
+type contentItemContent struct {
+	Direction string `json:"direction"`
+	Content   string `json:"content"`
+}
+
+type contentItemOrigin struct {
+	StreamID string `json:"streamId"`
+	Title    string `json:"title"`
+	HTMLUrl  string `json:"htmlUrl"`
+}
+
+// Unauthorized sends a not authorized error to the client.
+func Unauthorized(w http.ResponseWriter, r *http.Request) {
+	logger.Error("[HTTP:Unauthorized] %s", r.URL)
+
+	builder := response.New(w, r)
+	builder.WithStatus(http.StatusUnauthorized)
+	builder.WithHeader("Content-Type", "text/plain")
+	builder.WithHeader("X-Reader-Google-Bad-Token", "true")
+	builder.WithBody("Unauthorized")
+	builder.Write()
+}
+
+// OK sends a ok response to the client.
+func OK(w http.ResponseWriter, r *http.Request) {
+	logger.Info("[HTTP:OK] %s", r.URL)
+
+	builder := response.New(w, r)
+	builder.WithStatus(http.StatusOK)
+	builder.WithHeader("Content-Type", "text/plain")
+	builder.WithBody("OK")
+	builder.Write()
+}

http/client.go

@@ -1,174 +0,0 @@
-// Copyright 2017 Frédéric Guillot. All rights reserved.
-// Use of this source code is governed by the Apache 2.0
-// license that can be found in the LICENSE file.
-
-package http
-
-import (
-	"bytes"
-	"crypto/tls"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/miniflux/miniflux/logger"
-	"github.com/miniflux/miniflux/timer"
-	"github.com/miniflux/miniflux/version"
-)
-
-const requestTimeout = 300
-const maxBodySize = 1024 * 1024 * 15
-
-// Client is a HTTP Client :)
-type Client struct {
-	url                 string
-	etagHeader          string
-	lastModifiedHeader  string
-	authorizationHeader string
-	username            string
-	password            string
-	Insecure            bool
-}
-
-// Get execute a GET HTTP request.
-func (c *Client) Get() (*Response, error) {
-	request, err := c.buildRequest(http.MethodGet, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return c.executeRequest(request)
-}
-
-// PostForm execute a POST HTTP request with form values.
-func (c *Client) PostForm(values url.Values) (*Response, error) {
-	request, err := c.buildRequest(http.MethodPost, strings.NewReader(values.Encode()))
-	if err != nil {
-		return nil, err
-	}
-
-	request.Header.Add("Content-Type", "application/x-www-form-urlencoded")
-	return c.executeRequest(request)
-}
-
-// PostJSON execute a POST HTTP request with JSON payload.
-func (c *Client) PostJSON(data interface{}) (*Response, error) {
-	b, err := json.Marshal(data)
-	if err != nil {
-		return nil, err
-	}
-
-	request, err := c.buildRequest(http.MethodPost, bytes.NewReader(b))
-	if err != nil {
-		return nil, err
-	}
-
-	request.Header.Add("Content-Type", "application/json")
-	return c.executeRequest(request)
-}
-
-func (c *Client) executeRequest(request *http.Request) (*Response, error) {
-	defer timer.ExecutionTime(time.Now(), fmt.Sprintf("[HttpClient] url=%s", c.url))
-
-	client := c.buildClient()
-	resp, err := client.Do(request)
-	if err != nil {
-		return nil, err
-	}
-
-	if resp.ContentLength > maxBodySize {
-		return nil, fmt.Errorf("client: response too large (%d bytes)", resp.ContentLength)
-	}
-
-	response := &Response{
-		Body:          resp.Body,
-		StatusCode:    resp.StatusCode,
-		EffectiveURL:  resp.Request.URL.String(),
-		LastModified:  resp.Header.Get("Last-Modified"),
-		ETag:          resp.Header.Get("ETag"),
-		ContentType:   resp.Header.Get("Content-Type"),
-		ContentLength: resp.ContentLength,
-	}
-
-	logger.Debug("[HttpClient:%s] OriginalURL=%s, StatusCode=%d, ContentLength=%d, ContentType=%s, ETag=%s, LastModified=%s, EffectiveURL=%s",
-		request.Method,
-		c.url,
-		response.StatusCode,
-		resp.ContentLength,
-		response.ContentType,
-		response.ETag,
-		response.LastModified,
-		response.EffectiveURL,
-	)
-
-	return response, err
-}
-
-func (c *Client) buildRequest(method string, body io.Reader) (*http.Request, error) {
-	request, err := http.NewRequest(method, c.url, body)
-	if err != nil {
-		return nil, err
-	}
-
-	if c.username != "" && c.password != "" {
-		request.SetBasicAuth(c.username, c.password)
-	}
-
-	request.Header = c.buildHeaders()
-	return request, nil
-}
-
-func (c *Client) buildClient() http.Client {
-	client := http.Client{Timeout: time.Duration(requestTimeout * time.Second)}
-	if c.Insecure {
-		client.Transport = &http.Transport{
-			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-		}
-	}
-
-	return client
-}
-
-func (c *Client) buildHeaders() http.Header {
-	headers := make(http.Header)
-	headers.Add("User-Agent", "Mozilla/5.0 (compatible; Miniflux/"+version.Version+"; +https://miniflux.net)")
-	headers.Add("Accept", "*/*")
-
-	if c.etagHeader != "" {
-		headers.Add("If-None-Match", c.etagHeader)
-	}
-
-	if c.lastModifiedHeader != "" {
-		headers.Add("If-Modified-Since", c.lastModifiedHeader)
-	}
-
-	if c.authorizationHeader != "" {
-		headers.Add("Authorization", c.authorizationHeader)
-	}
-
-	return headers
-}
-
-// NewClient returns a new HTTP client.
-func NewClient(url string) *Client {
-	return &Client{url: url, Insecure: false}
-}
-
-// NewClientWithCredentials returns a new HTTP client that requires authentication.
-func NewClientWithCredentials(url, username, password string) *Client {
-	return &Client{url: url, Insecure: false, username: username, password: password}
-}
-
-// NewClientWithAuthorization returns a new client with a custom authorization header.
-func NewClientWithAuthorization(url, authorization string) *Client {
-	return &Client{url: url, Insecure: false, authorizationHeader: authorization}
-}
-
-// NewClientWithCacheHeaders returns a new HTTP client that send cache headers.
-func NewClientWithCacheHeaders(url, etagHeader, lastModifiedHeader string) *Client {
-	return &Client{url: url, etagHeader: etagHeader, lastModifiedHeader: lastModifiedHeader, Insecure: false}
-}

http/client/client.go

@@ -0,0 +1,350 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package client // import "miniflux.app/http/client"
+
+import (
+	"bytes"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"miniflux.app/config"
+	"miniflux.app/errors"
+	"miniflux.app/logger"
+	"miniflux.app/timer"
+)
+
+const (
+	defaultHTTPClientTimeout     = 20
+	defaultHTTPClientMaxBodySize = 15 * 1024 * 1024
+)
+
+var (
+	errInvalidCertificate        = "Invalid SSL certificate (original error: %q)"
+	errTemporaryNetworkOperation = "This website is temporarily unreachable (original error: %q)"
+	errPermanentNetworkOperation = "This website is permanently unreachable (original error: %q)"
+	errRequestTimeout            = "Website unreachable, the request timed out after %d seconds"
+)
+
+// Client builds and executes HTTP requests.
+type Client struct {
+	inputURL string
+
+	requestEtagHeader          string
+	requestLastModifiedHeader  string
+	requestAuthorizationHeader string
+	requestUsername            string
+	requestPassword            string
+	requestUserAgent           string
+	requestCookie              string
+
+	useProxy             bool
+	doNotFollowRedirects bool
+
+	ClientTimeout               int
+	ClientMaxBodySize           int64
+	ClientProxyURL              string
+	AllowSelfSignedCertificates bool
+}
+
+// New initializes a new HTTP client.
+func New(url string) *Client {
+	return &Client{
+		inputURL:          url,
+		ClientTimeout:     defaultHTTPClientTimeout,
+		ClientMaxBodySize: defaultHTTPClientMaxBodySize,
+	}
+}
+
+// NewClientWithConfig initializes a new HTTP client with application config options.
+func NewClientWithConfig(url string, opts *config.Options) *Client {
+	return &Client{
+		inputURL:          url,
+		requestUserAgent:  opts.HTTPClientUserAgent(),
+		ClientTimeout:     opts.HTTPClientTimeout(),
+		ClientMaxBodySize: opts.HTTPClientMaxBodySize(),
+		ClientProxyURL:    opts.HTTPClientProxy(),
+	}
+}
+
+func (c *Client) String() string {
+	etagHeader := c.requestEtagHeader
+	if c.requestEtagHeader == "" {
+		etagHeader = "None"
+	}
+
+	lastModifiedHeader := c.requestLastModifiedHeader
+	if c.requestLastModifiedHeader == "" {
+		lastModifiedHeader = "None"
+	}
+
+	return fmt.Sprintf(
+		`InputURL=%q ETag=%s LastMod=%s Auth=%v UserAgent=%q Verify=%v`,
+		c.inputURL,
+		etagHeader,
+		lastModifiedHeader,
+		c.requestAuthorizationHeader != "" || (c.requestUsername != "" && c.requestPassword != ""),
+		c.requestUserAgent,
+		!c.AllowSelfSignedCertificates,
+	)
+}
+
+// WithCredentials defines the username/password for HTTP Basic authentication.
+func (c *Client) WithCredentials(username, password string) *Client {
+	if username != "" && password != "" {
+		c.requestUsername = username
+		c.requestPassword = password
+	}
+	return c
+}
+
+// WithAuthorization defines the authorization HTTP header value.
+func (c *Client) WithAuthorization(authorization string) *Client {
+	c.requestAuthorizationHeader = authorization
+	return c
+}
+
+// WithCacheHeaders defines caching headers.
+func (c *Client) WithCacheHeaders(etagHeader, lastModifiedHeader string) *Client {
+	c.requestEtagHeader = etagHeader
+	c.requestLastModifiedHeader = lastModifiedHeader
+	return c
+}
+
+// WithProxy enables proxy for the current HTTP request.
+func (c *Client) WithProxy() *Client {
+	c.useProxy = true
+	return c
+}
+
+// WithoutRedirects disables HTTP redirects.
+func (c *Client) WithoutRedirects() *Client {
+	c.doNotFollowRedirects = true
+	return c
+}
+
+// WithUserAgent defines the User-Agent header to use for HTTP requests.
+func (c *Client) WithUserAgent(userAgent string) *Client {
+	if userAgent != "" {
+		c.requestUserAgent = userAgent
+	}
+	return c
+}
+
+// WithCookie defines the Cookies to use for HTTP requests.
+func (c *Client) WithCookie(cookie string) *Client {
+	if cookie != "" {
+		c.requestCookie = cookie
+	}
+	return c
+}
+
+// Get performs a GET HTTP request.
+func (c *Client) Get() (*Response, error) {
+	request, err := c.buildRequest(http.MethodGet, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return c.executeRequest(request)
+}
+
+// PostForm performs a POST HTTP request with form encoded values.
+func (c *Client) PostForm(values url.Values) (*Response, error) {
+	request, err := c.buildRequest(http.MethodPost, strings.NewReader(values.Encode()))
+	if err != nil {
+		return nil, err
+	}
+
+	request.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+	return c.executeRequest(request)
+}
+
+// PostJSON performs a POST HTTP request with a JSON payload.
+func (c *Client) PostJSON(data interface{}) (*Response, error) {
+	b, err := json.Marshal(data)
+	if err != nil {
+		return nil, err
+	}
+
+	request, err := c.buildRequest(http.MethodPost, bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+
+	request.Header.Add("Content-Type", "application/json")
+	return c.executeRequest(request)
+}
+
+func (c *Client) executeRequest(request *http.Request) (*Response, error) {
+	defer timer.ExecutionTime(time.Now(), fmt.Sprintf("[HttpClient] inputURL=%s", c.inputURL))
+
+	logger.Debug("[HttpClient:Before] Method=%s %s",
+		request.Method,
+		c.String(),
+	)
+
+	client := c.buildClient()
+	resp, err := client.Do(request)
+	if resp != nil {
+		defer resp.Body.Close()
+	}
+
+	if err != nil {
+		if uerr, ok := err.(*url.Error); ok {
+			switch uerr.Err.(type) {
+			case x509.CertificateInvalidError, x509.HostnameError:
+				err = errors.NewLocalizedError(errInvalidCertificate, uerr.Err)
+			case *net.OpError:
+				if uerr.Err.(*net.OpError).Temporary() {
+					err = errors.NewLocalizedError(errTemporaryNetworkOperation, uerr.Err)
+				} else {
+					err = errors.NewLocalizedError(errPermanentNetworkOperation, uerr.Err)
+				}
+			case net.Error:
+				nerr := uerr.Err.(net.Error)
+				if nerr.Timeout() {
+					err = errors.NewLocalizedError(errRequestTimeout, c.ClientTimeout)
+				} else if nerr.Temporary() {
+					err = errors.NewLocalizedError(errTemporaryNetworkOperation, nerr)
+				}
+			}
+		}
+
+		return nil, err
+	}
+
+	if resp.ContentLength > c.ClientMaxBodySize {
+		return nil, fmt.Errorf("client: response too large (%d bytes)", resp.ContentLength)
+	}
+
+	buf, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("client: error while reading body %v", err)
+	}
+
+	response := &Response{
+		Body:          bytes.NewReader(buf),
+		StatusCode:    resp.StatusCode,
+		EffectiveURL:  resp.Request.URL.String(),
+		LastModified:  resp.Header.Get("Last-Modified"),
+		ETag:          resp.Header.Get("ETag"),
+		Expires:       resp.Header.Get("Expires"),
+		ContentType:   resp.Header.Get("Content-Type"),
+		ContentLength: resp.ContentLength,
+	}
+
+	logger.Debug("[HttpClient:After] Method=%s %s; Response => %s",
+		request.Method,
+		c.String(),
+		response,
+	)
+
+	// Ignore caching headers for feeds that do not want any cache.
+	if resp.Header.Get("Expires") == "0" {
+		logger.Debug("[HttpClient] Ignore caching headers for %q", response.EffectiveURL)
+		response.ETag = ""
+		response.LastModified = ""
+	}
+
+	return response, err
+}
+
+func (c *Client) buildRequest(method string, body io.Reader) (*http.Request, error) {
+	request, err := http.NewRequest(method, c.inputURL, body)
+	if err != nil {
+		return nil, err
+	}
+
+	request.Header = c.buildHeaders()
+
+	if c.requestUsername != "" && c.requestPassword != "" {
+		request.SetBasicAuth(c.requestUsername, c.requestPassword)
+	}
+
+	return request, nil
+}
+
+func (c *Client) buildClient() http.Client {
+	client := http.Client{
+		Timeout: time.Duration(c.ClientTimeout) * time.Second,
+	}
+
+	transport := &http.Transport{
+		Proxy: http.ProxyFromEnvironment,
+		DialContext: (&net.Dialer{
+			// Default is 30s.
+			Timeout: 10 * time.Second,
+
+			// Default is 30s.
+			KeepAlive: 15 * time.Second,
+		}).DialContext,
+
+		// Default is 100.
+		MaxIdleConns: 50,
+
+		// Default is 90s.
+		IdleConnTimeout: 10 * time.Second,
+	}
+
+	if c.AllowSelfSignedCertificates {
+		transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
+	}
+
+	if c.doNotFollowRedirects {
+		client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		}
+	}
+
+	if c.useProxy && c.ClientProxyURL != "" {
+		proxyURL, err := url.Parse(c.ClientProxyURL)
+		if err != nil {
+			logger.Error("[HttpClient] Proxy URL error: %v", err)
+		} else {
+			logger.Debug("[HttpClient] Use proxy: %s", proxyURL)
+			transport.Proxy = http.ProxyURL(proxyURL)
+		}
+	}
+
+	client.Transport = transport
+
+	return client
+}
+
+func (c *Client) buildHeaders() http.Header {
+	headers := make(http.Header)
+	headers.Add("Accept", "*/*")
+
+	if c.requestUserAgent != "" {
+		headers.Add("User-Agent", c.requestUserAgent)
+	}
+
+	if c.requestEtagHeader != "" {
+		headers.Add("If-None-Match", c.requestEtagHeader)
+	}
+
+	if c.requestLastModifiedHeader != "" {
+		headers.Add("If-Modified-Since", c.requestLastModifiedHeader)
+	}
+
+	if c.requestAuthorizationHeader != "" {
+		headers.Add("Authorization", c.requestAuthorizationHeader)
+	}
+
+	if c.requestCookie != "" {
+		headers.Add("Cookie", c.requestCookie)
+	}
+
+	headers.Add("Connection", "close")
+	return headers
+}

http/client/client_test.go

@@ -0,0 +1,53 @@
+// Copyright 2020 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+package client // import "miniflux.app/http/client"
+
+import (
+	"testing"
+)
+
+func TestClientWithDelay(t *testing.T) {
+	clt := New("http://httpbin.org/delay/5")
+	clt.ClientTimeout = 1
+	_, err := clt.Get()
+	if err == nil {
+		t.Fatal(`The client should stops after 1 second`)
+	}
+}
+
+func TestClientWithError(t *testing.T) {
+	clt := New("http://httpbin.org/status/502")
+	clt.ClientTimeout = 5
+	response, err := clt.Get()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if response.StatusCode != 502 {
+		t.Fatalf(`Unexpected response status code: %d`, response.StatusCode)
+	}
+
+	if !response.HasServerFailure() {
+		t.Fatal(`A 502 error is considered as server failure`)
+	}
+}
+
+func TestClientWithResponseTooLarge(t *testing.T) {
+	clt := New("http://httpbin.org/bytes/100")
+	clt.ClientMaxBodySize = 10
+	_, err := clt.Get()
+	if err == nil {
+		t.Fatal(`The client should fails when reading a response too large`)
+	}
+}
+
+func TestClientWithBasicAuth(t *testing.T) {
+	clt := New("http://httpbin.org/basic-auth/testuser/testpassword")
+	clt.WithCredentials("testuser", "testpassword")
+	_, err := clt.Get()
+	if err != nil {
+		t.Fatalf(`The client should be authenticated successfully: %v`, err)
+	}
+}

http/client/doc.go

@@ -0,0 +1,10 @@
+// Copyright 2018 Frédéric Guillot. All rights reserved.
+// Use of this source code is governed by the Apache 2.0
+// license that can be found in the LICENSE file.
+
+/*
+
+Package client provides an HTTP client builder.
+
+*/
+package client // import "miniflux.app/http/client"