Update ChangeLog

This reverts commit c9618458cb.

.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/workflows/ci.yml

@@ -0,0 +1,95 @@
+name: CI Workflow
+on:
+  pull_request:
+    branches:
+    - master
+
+jobs:
+
+  linters:
+    name: Linter Check
+    runs-on: ubuntu-latest
+    steps:
+    - name: Set up Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: 1.14
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - name: Checkout
+      uses: actions/checkout@v1
+      with:
+        fetch-depth: 3
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - name: Install linters
+      run: |
+        cd /tmp && go get -u golang.org/x/lint/golint
+        sudo npm install -g jshint
+      env:
+        GO111MODULE: off
+    - name: Run golint
+      run: |
+        export PATH=/home/runner/go/bin:$PATH
+        make lint
+    - name: Run jshint
+      run: jshint ui/static/js/*.js
+
+  unit-tests:
+    name: Unit Tests
+    runs-on: ${{ matrix.os }}
+    strategy:
+      max-parallel: 4
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+        go-version: [1.11, 1.12, 1.13, 1.14]
+    steps:
+    - name: Set up Go
+      uses: actions/setup-go@v1
+      with:
+        go-version: ${{ matrix.go-version }}
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - name: Checkout
+      uses: actions/checkout@v1
+      with:
+        fetch-depth: 3
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - 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@v1
+      with:
+        go-version: 1.14
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - name: Checkout
+      uses: actions/checkout@v1
+      with:
+        fetch-depth: 3
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    - 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

.gitignore

@@ -1 +1,2 @@
 miniflux-*
+miniflux

.travis.yml

@@ -1,17 +0,0 @@
-notifications:
-  email: false
-services:
-  - postgresql
-addons:
-  postgresql: "9.4"
-language: go
-go:
-  - "1.10"
-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,358 @@
+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 possiblity 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)
 ----------------------------
 

Dockerfile

@@ -0,0 +1,19 @@
+ARG BASE_IMAGE_ARCH="amd64"
+ARG ALPINE_LINUX_VERSION="3.12"
+
+FROM golang:1-alpine${ALPINE_LINUX_VERSION} as build
+ARG APP_VERSION
+ARG APP_ARCH="amd64"
+WORKDIR /go/src/app
+RUN apk add --no-cache --update build-base git
+COPY . .
+RUN make linux-${APP_ARCH} VERSION=${APP_VERSION}
+RUN cp /go/src/app/miniflux-linux-${APP_ARCH} /go/src/app/miniflux
+
+FROM ${BASE_IMAGE_ARCH}/alpine:${ALPINE_LINUX_VERSION}
+EXPOSE 8080
+ENV LISTEN_ADDR 0.0.0.0:8080
+RUN apk --no-cache add ca-certificates tzdata
+COPY --from=build /go/src/app/miniflux /usr/bin/miniflux
+USER nobody
+CMD ["/usr/bin/miniflux"]

Gopkg.lock

@@ -1,157 +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 = "53c1911da2b537f792e7cafcb446b05ffe33b996"
-  version = "v1.6.1"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/lib/pq"
-  packages = [
-    ".",
-    "hstore",
-    "oid"
-  ]
-  revision = "83612a56d3dd153a94a629cd64925371c9adad78"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/miniflux/miniflux-go"
-  packages = ["."]
-  revision = "cfb76c59831603c2b57e03356e9241facfa9834e"
-
-[[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 = "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 = "f030af166f90ac96d133b7ddf9f1f80785508462cac8cae4c65abbdb7c20474b"
-  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"
-
-[metadata.heroku]
-  root-package = "github.com/miniflux/miniflux"
-  go-version = "go1.10"
-  ensure = "false"
-
-[[constraint]]
-  name = "github.com/PuerkitoBio/goquery"
-  version = "1.1.0"
-
-[[constraint]]
-  name = "github.com/gorilla/mux"
-  version = "1.6.1"
-
-[[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 = "golang.org/x/crypto"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/net"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/oauth2"

Makefile

@@ -1,44 +1,107 @@
 APP := miniflux
-VERSION=$(shell git rev-parse --short HEAD)
-BUILD_DATE=`date +%FT%T%z`
+DOCKER_IMAGE := miniflux/miniflux
+VERSION := $(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.BuildDate=$(BUILD_DATE)'"
 PKG_LIST := $(shell go list ./... | grep -v /vendor/)
 DB_URL := postgres://postgres:postgres@localhost/miniflux_test?sslmode=disable
 
-.PHONY: linux linux-arm darwin freebsd build run clean test lint integration-test clean-integration-test
+export PGPASSWORD := postgres
+export GO111MODULE=on
 
-linux:
-	@ go generate
-	@ GOOS=linux GOARCH=amd64 go build -ldflags="-s -w -X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-linux-amd64 main.go
+.PHONY: generate \
+	miniflux \
+	linux-amd64 \
+	linux-armv8 \
+	linux-armv7 \
+	linux-armv6 \
+	linux-armv5 \
+	linux-x86 \
+	darwin-amd64 \
+	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-images \
+	docker-manifest
 
-linux-arm:
-	@ go generate
-	@ GOOS=linux GOARCH=arm64 go build -ldflags="-s -w -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="-s -w -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="-s -w -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="-s -w -X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-linux-armv5 main.go
+generate:
+	@ go generate -mod=vendor
 
-darwin:
-	@ go generate
-	@ GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w -X 'github.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-darwin-amd64 main.go
+miniflux: generate
+	@ go build -ldflags=$(LD_FLAGS) -o $(APP) main.go
 
-freebsd:
-	@ go generate
-	@ GOOS=freebsd GOARCH=amd64 go build -ldflags="-s -w -X 'githug.com/miniflux/miniflux/version.Version=$(VERSION)' -X 'github.com/miniflux/miniflux/version.BuildDate=$(BUILD_DATE)'" -o $(APP)-freebsd-amd64 main.go
+linux-amd64: generate
+	@ GOOS=linux GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-amd64 main.go
 
-build: linux linux-arm darwin freebsd
+linux-armv8: generate
+	@ GOOS=linux GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-armv8 main.go
 
-run:
-	@ go generate
+linux-armv7: generate
+	@ GOOS=linux GOARCH=arm GOARM=7 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-armv7 main.go
+
+linux-armv6: generate
+	@ GOOS=linux GOARCH=arm GOARM=6 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-armv6 main.go
+
+linux-armv5: generate
+	@ GOOS=linux GOARCH=arm GOARM=5 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-armv5 main.go
+
+darwin-amd64: generate
+	@ GOOS=darwin GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-darwin-amd64 main.go
+
+freebsd-amd64: generate
+	@ GOOS=freebsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-freebsd-amd64 main.go
+
+openbsd-amd64: generate
+	@ GOOS=openbsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-openbsd-amd64 main.go
+
+windows-amd64: generate
+	@ GOOS=windows GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-windows-amd64 main.go
+
+build: linux-amd64 linux-armv8 linux-armv7 linux-armv6 linux-armv5 darwin-amd64 freebsd-amd64 openbsd-amd64 windows-amd64
+
+# NOTE: unsupported targets
+netbsd-amd64: generate
+	@ GOOS=netbsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-netbsd-amd64 main.go
+
+linux-x86: generate
+	@ GOOS=linux GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-linux-x86 main.go
+
+freebsd-x86: generate
+	@ GOOS=freebsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-freebsd-x86 main.go
+
+netbsd-x86: generate
+	@ GOOS=netbsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-netbsd-x86 main.go
+
+openbsd-x86: generate
+	@ GOOS=openbsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-freebsd-x86 main.go
+
+windows-x86: generate
+	@ GOOS=windows GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-windows-x86 main.go
+
+run: generate
 	@ go run main.go -debug
 
 clean:
-	@ rm -f $(APP)-*
+	@ rm -f $(APP)-* $(APP)
 
 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;'
@@ -48,10 +111,61 @@ integration-test:
 	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
+	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) \
+		--build-arg APP_VERSION=$(VERSION) \
+		--build-arg APP_ARCH=amd64 \
+		--build-arg BASE_IMAGE_ARCH=amd64 .
+
+docker-images:
+	docker build -t $(DOCKER_IMAGE):amd64-$(VERSION) \
+		--build-arg APP_VERSION=$(VERSION) \
+		--build-arg APP_ARCH=amd64 \
+		--build-arg BASE_IMAGE_ARCH=amd64 .
+	docker tag $(DOCKER_IMAGE):amd64-$(VERSION) $(DOCKER_IMAGE):amd64-latest
+
+	docker build -t $(DOCKER_IMAGE):arm32v6-$(VERSION) \
+		--build-arg APP_VERSION=$(VERSION) \
+		--build-arg APP_ARCH=armv6 \
+		--build-arg BASE_IMAGE_ARCH=arm32v6 .
+	docker tag $(DOCKER_IMAGE):arm32v6-$(VERSION) $(DOCKER_IMAGE):arm32v6-latest
+
+	docker build -t $(DOCKER_IMAGE):arm32v7-$(VERSION) \
+		--build-arg APP_VERSION=$(VERSION) \
+		--build-arg APP_ARCH=armv7 \
+		--build-arg BASE_IMAGE_ARCH=arm32v7 .
+	docker tag $(DOCKER_IMAGE):arm32v7-$(VERSION) $(DOCKER_IMAGE):arm32v7-latest
+
+	docker build -t $(DOCKER_IMAGE):arm64v8-$(VERSION) \
+		--build-arg APP_VERSION=$(VERSION) \
+		--build-arg APP_ARCH=armv8 \
+		--build-arg BASE_IMAGE_ARCH=arm64v8 .
+	docker tag $(DOCKER_IMAGE):arm64v8-$(VERSION) $(DOCKER_IMAGE):arm64v8-latest
+
+docker-manifest:
+	for version in $(VERSION) latest; do \
+		docker push $(DOCKER_IMAGE):amd64-$${version} && \
+		docker push $(DOCKER_IMAGE):arm32v6-$${version} && \
+		docker push $(DOCKER_IMAGE):arm32v7-$${version} && \
+		docker push $(DOCKER_IMAGE):arm64v8-$${version} && \
+		docker manifest create --amend $(DOCKER_IMAGE):$${version} \
+			$(DOCKER_IMAGE):amd64-$${version} \
+			$(DOCKER_IMAGE):arm32v6-$${version} \
+			$(DOCKER_IMAGE):arm32v7-$${version} \
+			$(DOCKER_IMAGE):arm64v8-$${version} && \
+		docker manifest annotate $(DOCKER_IMAGE):$${version} \
+			$(DOCKER_IMAGE):arm32v6-$${version} --os linux --arch arm --variant v6 && \
+		docker manifest annotate $(DOCKER_IMAGE):$${version} \
+			$(DOCKER_IMAGE):arm32v7-$${version} --os linux --arch arm --variant v7 && \
+		docker manifest annotate $(DOCKER_IMAGE):$${version} \
+			$(DOCKER_IMAGE):arm64v8-$${version} --os linux --arch arm64 --variant v8 && \
+		docker manifest push --purge $(DOCKER_IMAGE):$${version} ;\
+	done

Procfile

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

README.md

@@ -1,8 +1,6 @@
 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/)
+[![GoDoc](https://godoc.org/miniflux.app?status.svg)](https://godoc.org/miniflux.app)
 
 Miniflux is a minimalist and opinionated feed reader:
 
@@ -11,27 +9,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 Instructions](https://docs.miniflux.net/en/latest/installation.html)
-- [Installation Tutorials](https://docs.miniflux.net/en/latest/tutorials.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/miniflux/graphs/contributors)
 - Distributed under Apache 2.0 License

api/api.go

@@ -0,0 +1,51 @@
+// 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 (
+	"miniflux.app/reader/feed"
+	"miniflux.app/storage"
+	"miniflux.app/worker"
+
+	"github.com/gorilla/mux"
+)
+
+// Serve declares API routes for the application.
+func Serve(router *mux.Router, store *storage.Storage, pool *worker.Pool, feedHandler *feed.Handler) {
+	handler := &handler{store, pool, feedHandler}
+
+	sr := router.PathPrefix("/v1").Subrouter()
+	middleware := newMiddleware(store)
+	sr.Use(middleware.apiKeyAuth)
+	sr.Use(middleware.basicAuth)
+	sr.HandleFunc("/users", handler.createUser).Methods("POST")
+	sr.HandleFunc("/users", handler.users).Methods("GET")
+	sr.HandleFunc("/users/{userID:[0-9]+}", handler.userByID).Methods("GET")
+	sr.HandleFunc("/users/{userID:[0-9]+}", handler.updateUser).Methods("PUT")
+	sr.HandleFunc("/users/{userID:[0-9]+}", handler.removeUser).Methods("DELETE")
+	sr.HandleFunc("/users/{username}", handler.userByUsername).Methods("GET")
+	sr.HandleFunc("/me", handler.currentUser).Methods("GET")
+	sr.HandleFunc("/categories", handler.createCategory).Methods("POST")
+	sr.HandleFunc("/categories", handler.getCategories).Methods("GET")
+	sr.HandleFunc("/categories/{categoryID}", handler.updateCategory).Methods("PUT")
+	sr.HandleFunc("/categories/{categoryID}", handler.removeCategory).Methods("DELETE")
+	sr.HandleFunc("/discover", handler.getSubscriptions).Methods("POST")
+	sr.HandleFunc("/feeds", handler.createFeed).Methods("POST")
+	sr.HandleFunc("/feeds", handler.getFeeds).Methods("GET")
+	sr.HandleFunc("/feeds/refresh", handler.refreshAllFeeds).Methods("PUT")
+	sr.HandleFunc("/feeds/{feedID}/refresh", handler.refreshFeed).Methods("PUT")
+	sr.HandleFunc("/feeds/{feedID}", handler.getFeed).Methods("GET")
+	sr.HandleFunc("/feeds/{feedID}", handler.updateFeed).Methods("PUT")
+	sr.HandleFunc("/feeds/{feedID}", handler.removeFeed).Methods("DELETE")
+	sr.HandleFunc("/feeds/{feedID}/icon", handler.feedIcon).Methods("GET")
+	sr.HandleFunc("/export", handler.exportFeeds).Methods("GET")
+	sr.HandleFunc("/import", handler.importFeeds).Methods("POST")
+	sr.HandleFunc("/feeds/{feedID}/entries", handler.getFeedEntries).Methods("GET")
+	sr.HandleFunc("/feeds/{feedID}/entries/{entryID}", handler.getFeedEntry).Methods("GET")
+	sr.HandleFunc("/entries", handler.getEntries).Methods("GET")
+	sr.HandleFunc("/entries", handler.setEntryStatus).Methods("PUT")
+	sr.HandleFunc("/entries/{entryID}", handler.getEntry).Methods("GET")
+	sr.HandleFunc("/entries/{entryID}/bookmark", handler.toggleBookmark).Methods("PUT")
+}

api/category.go

@@ -2,109 +2,91 @@
 // 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/context"
-	"github.com/miniflux/miniflux/http/request"
-	"github.com/miniflux/miniflux/http/response/json"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
 )
 
-// CreateCategory is the API handler to create a new category.
-func (c *Controller) CreateCategory(w http.ResponseWriter, r *http.Request) {
+func (h *handler) createCategory(w http.ResponseWriter, r *http.Request) {
 	category, err := decodeCategoryPayload(r.Body)
 	if err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	ctx := context.New(r)
-	userID := ctx.UserID()
+	userID := request.UserID(r)
 	category.UserID = userID
 	if err := category.ValidateCategoryCreation(); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	if c, err := c.store.CategoryByTitle(userID, category.Title); err != nil || c != nil {
-		json.BadRequest(w, errors.New("This category already exists"))
+	if c, err := h.store.CategoryByTitle(userID, category.Title); err != nil || c != nil {
+		json.BadRequest(w, r, errors.New("This category already exists"))
 		return
 	}
 
-	err = c.store.CreateCategory(category)
-	if err != nil {
-		json.ServerError(w, errors.New("Unable to create this category"))
+	if err := h.store.CreateCategory(category); err != nil {
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.Created(w, category)
+	json.Created(w, r, category)
 }
 
-// UpdateCategory is the API handler to update a category.
-func (c *Controller) UpdateCategory(w http.ResponseWriter, r *http.Request) {
-	categoryID, err := request.IntParam(r, "categoryID")
-	if err != nil {
-		json.BadRequest(w, err)
-		return
-	}
+func (h *handler) updateCategory(w http.ResponseWriter, r *http.Request) {
+	categoryID := request.RouteInt64Param(r, "categoryID")
 
 	category, err := decodeCategoryPayload(r.Body)
 	if err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	ctx := context.New(r)
-	category.UserID = ctx.UserID()
+	category.UserID = request.UserID(r)
 	category.ID = categoryID
 	if err := category.ValidateCategoryModification(); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	err = c.store.UpdateCategory(category)
+	err = h.store.UpdateCategory(category)
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to update this category"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.Created(w, 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(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	categories, err := c.store.Categories(ctx.UserID())
+func (h *handler) getCategories(w http.ResponseWriter, r *http.Request) {
+	categories, err := h.store.Categories(request.UserID(r))
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch categories"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.OK(w, categories)
+	json.OK(w, r, categories)
 }
 
-// RemoveCategory is the API handler to remove a category.
-func (c *Controller) RemoveCategory(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
-	categoryID, err := request.IntParam(r, "categoryID")
-	if err != nil {
-		json.BadRequest(w, err)
+func (h *handler) removeCategory(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+	categoryID := request.RouteInt64Param(r, "categoryID")
+
+	if !h.store.CategoryExists(userID, categoryID) {
+		json.NotFound(w, r)
 		return
 	}
 
-	if !c.store.CategoryExists(userID, categoryID) {
-		json.NotFound(w, errors.New("Category not found"))
+	if err := h.store.RemoveCategory(userID, categoryID); err != nil {
+		json.ServerError(w, r, err)
 		return
 	}
 
-	if err := c.store.RemoveCategory(userID, categoryID); err != nil {
-		json.ServerError(w, errors.New("Unable to remove this category"))
-		return
-	}
-
-	json.NoContent(w)
+	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 +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 api implements API endpoints for Miniflux application.
+Package api implements API endpoints for the application.
 
 */
-package api
+package api // import "miniflux.app/api"

api/entry.go

@@ -2,116 +2,91 @@
 // 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"
 	"time"
 
-	"github.com/miniflux/miniflux/http/context"
-	"github.com/miniflux/miniflux/http/request"
-	"github.com/miniflux/miniflux/http/response/json"
-	"github.com/miniflux/miniflux/model"
-	"github.com/miniflux/miniflux/storage"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/model"
+	"miniflux.app/storage"
 )
 
-// GetFeedEntry is the API handler to get a single feed entry.
-func (c *Controller) GetFeedEntry(w http.ResponseWriter, r *http.Request) {
-	feedID, err := request.IntParam(r, "feedID")
-	if err != nil {
-		json.BadRequest(w, err)
-		return
-	}
+func (h *handler) getFeedEntry(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
+	entryID := request.RouteInt64Param(r, "entryID")
 
-	entryID, err := request.IntParam(r, "entryID")
-	if err != nil {
-		json.BadRequest(w, err)
-		return
-	}
-
-	ctx := context.New(r)
-	userID := ctx.UserID()
-
-	builder := c.store.NewEntryQueryBuilder(userID)
+	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
 	builder.WithFeedID(feedID)
 	builder.WithEntryID(entryID)
 
 	entry, err := builder.GetEntry()
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch this entry from the database"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	if entry == nil {
-		json.NotFound(w, errors.New("Entry not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	json.OK(w, entry)
+	json.OK(w, r, entry)
 }
 
-// GetEntry is the API handler to get a single entry.
-func (c *Controller) GetEntry(w http.ResponseWriter, r *http.Request) {
-	entryID, err := request.IntParam(r, "entryID")
-	if err != nil {
-		json.BadRequest(w, err)
-		return
-	}
-
-	builder := c.store.NewEntryQueryBuilder(context.New(r).UserID())
+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)
 
 	entry, err := builder.GetEntry()
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch this entry from the database"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	if entry == nil {
-		json.NotFound(w, errors.New("Entry not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	json.OK(w, entry)
+	json.OK(w, r, entry)
 }
 
-// GetFeedEntries is the API handler to get all feed entries.
-func (c *Controller) GetFeedEntries(w http.ResponseWriter, r *http.Request) {
-	feedID, err := request.IntParam(r, "feedID")
-	if err != nil {
-		json.BadRequest(w, err)
-		return
-	}
+func (h *handler) getFeedEntries(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
 
-	status := request.QueryParam(r, "status", "")
+	status := request.QueryStringParam(r, "status", "")
 	if status != "" {
 		if err := model.ValidateEntryStatus(status); err != nil {
-			json.BadRequest(w, err)
+			json.BadRequest(w, r, err)
 			return
 		}
 	}
 
-	order := request.QueryParam(r, "order", model.DefaultSortingOrder)
+	order := request.QueryStringParam(r, "order", model.DefaultSortingOrder)
 	if err := model.ValidateEntryOrder(order); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	direction := request.QueryParam(r, "direction", model.DefaultSortingDirection)
+	direction := request.QueryStringParam(r, "direction", model.DefaultSortingDirection)
 	if err := model.ValidateDirection(direction); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
 	limit := request.QueryIntParam(r, "limit", 100)
 	offset := request.QueryIntParam(r, "offset", 0)
 	if err := model.ValidateRange(offset, limit); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	builder := c.store.NewEntryQueryBuilder(context.New(r).UserID())
+	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
 	builder.WithFeedID(feedID)
 	builder.WithStatus(status)
 	builder.WithOrder(order)
@@ -122,49 +97,48 @@ func (c *Controller) GetFeedEntries(w http.ResponseWriter, r *http.Request) {
 
 	entries, err := builder.GetEntries()
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch the list of entries"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	count, err := builder.CountEntries()
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to count the number of entries"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.OK(w, &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(w http.ResponseWriter, r *http.Request) {
-	status := request.QueryParam(r, "status", "")
+func (h *handler) getEntries(w http.ResponseWriter, r *http.Request) {
+	status := request.QueryStringParam(r, "status", "")
 	if status != "" {
 		if err := model.ValidateEntryStatus(status); err != nil {
-			json.BadRequest(w, err)
+			json.BadRequest(w, r, err)
 			return
 		}
 	}
 
-	order := request.QueryParam(r, "order", model.DefaultSortingOrder)
+	order := request.QueryStringParam(r, "order", model.DefaultSortingOrder)
 	if err := model.ValidateEntryOrder(order); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	direction := request.QueryParam(r, "direction", model.DefaultSortingDirection)
+	direction := request.QueryStringParam(r, "direction", model.DefaultSortingDirection)
 	if err := model.ValidateDirection(direction); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
 	limit := request.QueryIntParam(r, "limit", 100)
 	offset := request.QueryIntParam(r, "offset", 0)
 	if err := model.ValidateRange(offset, limit); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	builder := c.store.NewEntryQueryBuilder(context.New(r).UserID())
+	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
 	builder.WithStatus(status)
 	builder.WithOrder(order)
 	builder.WithDirection(direction)
@@ -174,78 +148,81 @@ func (c *Controller) GetEntries(w http.ResponseWriter, r *http.Request) {
 
 	entries, err := builder.GetEntries()
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch the list of entries"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	count, err := builder.CountEntries()
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to count the number of entries"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.OK(w, &entriesResponse{Total: count, Entries: entries})
+	json.OK(w, r, &entriesResponse{Total: count, Entries: entries})
 }
 
-// SetEntryStatus is the API handler to change the status of entries.
-func (c *Controller) SetEntryStatus(w http.ResponseWriter, r *http.Request) {
+func (h *handler) setEntryStatus(w http.ResponseWriter, r *http.Request) {
 	entryIDs, status, err := decodeEntryStatusPayload(r.Body)
 	if err != nil {
-		json.BadRequest(w, errors.New("Invalid JSON payload"))
+		json.BadRequest(w, r, errors.New("Invalid JSON payload"))
 		return
 	}
 
 	if err := model.ValidateEntryStatus(status); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	if err := c.store.SetEntriesStatus(context.New(r).UserID(), entryIDs, status); err != nil {
-		json.ServerError(w, errors.New("Unable to change entries status"))
+	if err := h.store.SetEntriesStatus(request.UserID(r), entryIDs, status); err != nil {
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.NoContent(w)
+	json.NoContent(w, r)
 }
 
-// ToggleBookmark is the API handler to toggle bookmark status.
-func (c *Controller) ToggleBookmark(w http.ResponseWriter, r *http.Request) {
-	entryID, err := request.IntParam(r, "entryID")
-	if err != nil {
-		json.BadRequest(w, err)
+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
 	}
 
-	if err := c.store.ToggleBookmark(context.New(r).UserID(), entryID); err != nil {
-		json.ServerError(w, errors.New("Unable to toggle bookmark value"))
-		return
-	}
-
-	json.NoContent(w)
+	json.NoContent(w, r)
 }
 
 func configureFilters(builder *storage.EntryQueryBuilder, r *http.Request) {
 	beforeEntryID := request.QueryInt64Param(r, "before_entry_id", 0)
-	if beforeEntryID != 0 {
+	if beforeEntryID > 0 {
 		builder.BeforeEntryID(beforeEntryID)
 	}
 
 	afterEntryID := request.QueryInt64Param(r, "after_entry_id", 0)
-	if afterEntryID != 0 {
+	if afterEntryID > 0 {
 		builder.AfterEntryID(afterEntryID)
 	}
 
 	beforeTimestamp := request.QueryInt64Param(r, "before", 0)
-	if beforeTimestamp != 0 {
+	if beforeTimestamp > 0 {
 		builder.BeforeDate(time.Unix(beforeTimestamp, 0))
 	}
 
 	afterTimestamp := request.QueryInt64Param(r, "after", 0)
-	if afterTimestamp != 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") {
 		builder.WithStarred()
 	}
+
+	searchQuery := request.QueryStringParam(r, "search", "")
+	if searchQuery != "" {
+		builder.WithSearchQuery(searchQuery)
+	}
 }

api/feed.go

@@ -2,58 +2,58 @@
 // 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/context"
-	"github.com/miniflux/miniflux/http/request"
-	"github.com/miniflux/miniflux/http/response/json"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
 )
 
-// CreateFeed is the API handler to create a new feed.
-func (c *Controller) CreateFeed(w http.ResponseWriter, r *http.Request) {
+func (h *handler) createFeed(w http.ResponseWriter, r *http.Request) {
 	feedInfo, err := decodeFeedCreationPayload(r.Body)
 	if err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
 	if feedInfo.FeedURL == "" {
-		json.BadRequest(w, errors.New("The feed_url is required"))
+		json.BadRequest(w, r, errors.New("The feed_url is required"))
 		return
 	}
 
 	if feedInfo.CategoryID <= 0 {
-		json.BadRequest(w, errors.New("The category_id is required"))
+		json.BadRequest(w, r, errors.New("The category_id is required"))
 		return
 	}
 
-	ctx := context.New(r)
-	userID := ctx.UserID()
+	userID := request.UserID(r)
 
-	if c.store.FeedURLExists(userID, feedInfo.FeedURL) {
-		json.BadRequest(w, errors.New("This feed_url already exists"))
+	if h.store.FeedURLExists(userID, feedInfo.FeedURL) {
+		json.BadRequest(w, r, errors.New("This feed_url already exists"))
 		return
 	}
 
-	if !c.store.CategoryExists(userID, feedInfo.CategoryID) {
-		json.BadRequest(w, errors.New("This category_id doesn't exists or doesn't belongs to this user"))
+	if !h.store.CategoryExists(userID, feedInfo.CategoryID) {
+		json.BadRequest(w, r, errors.New("This category_id doesn't exists or doesn't belongs to this user"))
 		return
 	}
 
-	feed, err := c.feedHandler.CreateFeed(
+	feed, err := h.feedHandler.CreateFeed(
 		userID,
 		feedInfo.CategoryID,
 		feedInfo.FeedURL,
 		feedInfo.Crawler,
+		feedInfo.UserAgent,
 		feedInfo.Username,
 		feedInfo.Password,
+		feedInfo.ScraperRules,
+		feedInfo.RewriteRules,
 	)
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to create this feed"))
+		json.ServerError(w, r, err)
 		return
 	}
 
@@ -61,136 +61,123 @@ func (c *Controller) CreateFeed(w http.ResponseWriter, r *http.Request) {
 		FeedID int64 `json:"feed_id"`
 	}
 
-	json.Created(w, &result{FeedID: feed.ID})
+	json.Created(w, r, &result{FeedID: feed.ID})
 }
 
-// RefreshFeed is the API handler to refresh a feed.
-func (c *Controller) RefreshFeed(w http.ResponseWriter, r *http.Request) {
-	feedID, err := request.IntParam(r, "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 := h.feedHandler.RefreshFeed(userID, feedID)
 	if err != nil {
-		json.BadRequest(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	ctx := context.New(r)
-	userID := ctx.UserID()
-
-	if !c.store.FeedExists(userID, feedID) {
-		json.NotFound(w, errors.New("Unable to find this feed"))
-		return
-	}
-
-	err = c.feedHandler.RefreshFeed(userID, feedID)
-	if err != nil {
-		json.ServerError(w, errors.New("Unable to refresh this feed"))
-		return
-	}
-
-	json.NoContent(w)
+	json.NoContent(w, r)
 }
 
-// UpdateFeed is the API handler that is used to update a feed.
-func (c *Controller) UpdateFeed(w http.ResponseWriter, r *http.Request) {
-	feedID, err := request.IntParam(r, "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 {
-		json.BadRequest(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
+	go func() {
+		h.pool.Push(jobs)
+	}()
+
+	json.NoContent(w, r)
+}
+
+func (h *handler) updateFeed(w http.ResponseWriter, r *http.Request) {
+	feedID := request.RouteInt64Param(r, "feedID")
 	feedChanges, err := decodeFeedModificationPayload(r.Body)
 	if err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	ctx := context.New(r)
-	userID := ctx.UserID()
+	userID := request.UserID(r)
 
-	originalFeed, err := c.store.FeedByID(userID, feedID)
+	originalFeed, err := h.store.FeedByID(userID, feedID)
 	if err != nil {
-		json.NotFound(w, errors.New("Unable to find this feed"))
+		json.NotFound(w, r)
 		return
 	}
 
 	if originalFeed == nil {
-		json.NotFound(w, errors.New("Feed not found"))
+		json.NotFound(w, r)
 		return
 	}
 
 	feedChanges.Update(originalFeed)
 
-	if !c.store.CategoryExists(userID, originalFeed.Category.ID) {
-		json.BadRequest(w, errors.New("This category_id doesn't exists or doesn't belongs to this user"))
+	if !h.store.CategoryExists(userID, originalFeed.Category.ID) {
+		json.BadRequest(w, r, errors.New("This category_id doesn't exists or doesn't belongs to this user"))
 		return
 	}
 
-	if err := c.store.UpdateFeed(originalFeed); err != nil {
-		json.ServerError(w, errors.New("Unable to update this feed"))
+	if err := h.store.UpdateFeed(originalFeed); err != nil {
+		json.ServerError(w, r, err)
 		return
 	}
 
-	originalFeed, err = c.store.FeedByID(userID, feedID)
+	originalFeed, err = h.store.FeedByID(userID, feedID)
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch this feed"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.Created(w, 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(w http.ResponseWriter, r *http.Request) {
-	feeds, err := c.store.Feeds(context.New(r).UserID())
+func (h *handler) getFeeds(w http.ResponseWriter, r *http.Request) {
+	feeds, err := h.store.Feeds(request.UserID(r))
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch feeds from the database"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.OK(w, feeds)
+	json.OK(w, r, feeds)
 }
 
-// GetFeed is the API handler to get a feed.
-func (c *Controller) GetFeed(w http.ResponseWriter, r *http.Request) {
-	feedID, err := request.IntParam(r, "feedID")
+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.BadRequest(w, err)
-		return
-	}
-
-	feed, err := c.store.FeedByID(context.New(r).UserID(), feedID)
-	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch this feed"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	if feed == nil {
-		json.NotFound(w, errors.New("Feed not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	json.OK(w, feed)
+	json.OK(w, r, feed)
 }
 
-// RemoveFeed is the API handler to remove a feed.
-func (c *Controller) RemoveFeed(w http.ResponseWriter, r *http.Request) {
-	feedID, err := request.IntParam(r, "feedID")
-	if err != nil {
-		json.BadRequest(w, err)
+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
 	}
 
-	ctx := context.New(r)
-	userID := ctx.UserID()
-
-	if !c.store.FeedExists(userID, feedID) {
-		json.NotFound(w, errors.New("Feed not found"))
+	if err := h.store.RemoveFeed(userID, feedID); err != nil {
+		json.ServerError(w, r, err)
 		return
 	}
 
-	if err := c.store.RemoveFeed(userID, feedID); err != nil {
-		json.ServerError(w, errors.New("Unable to remove this feed"))
-		return
-	}
-
-	json.NoContent(w)
+	json.NoContent(w, r)
 }

api/handler.go

@@ -0,0 +1,17 @@
+// 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 "miniflux.app/api"
+
+import (
+	"miniflux.app/reader/feed"
+	"miniflux.app/storage"
+	"miniflux.app/worker"
+)
+
+type handler struct {
+	store       *storage.Storage
+	pool        *worker.Pool
+	feedHandler *feed.Handler
+}

api/icon.go

@@ -2,42 +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/context"
-	"github.com/miniflux/miniflux/http/request"
-	"github.com/miniflux/miniflux/http/response/json"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
 )
 
-// FeedIcon returns a feed icon.
-func (c *Controller) FeedIcon(w http.ResponseWriter, r *http.Request) {
-	feedID, err := request.IntParam(r, "feedID")
-	if err != nil {
-		json.BadRequest(w, 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) {
-		json.NotFound(w, errors.New("This feed doesn't have any icon"))
-		return
-	}
-
-	icon, err := c.store.IconByFeedID(context.New(r).UserID(), feedID)
+	icon, err := h.store.IconByFeedID(request.UserID(r), feedID)
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch feed icon"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	if icon == nil {
-		json.NotFound(w, errors.New("This feed doesn't have any icon"))
+		json.NotFound(w, r)
 		return
 	}
 
-	json.OK(w, &feedIcon{
+	json.OK(w, r, &feedIcon{
 		ID:       icon.ID,
 		MimeType: icon.MimeType,
 		Data:     icon.DataURL(),

api/middleware.go

@@ -0,0 +1,110 @@
+// 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) 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 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

@@ -2,38 +2,36 @@
 // 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 (
 	"net/http"
 
-	"github.com/miniflux/miniflux/http/context"
-	"github.com/miniflux/miniflux/http/response/json"
-	"github.com/miniflux/miniflux/http/response/xml"
-	"github.com/miniflux/miniflux/reader/opml"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
+	"miniflux.app/http/response/xml"
+	"miniflux.app/reader/opml"
 )
 
-// Export is the API handler that export feeds to OPML.
-func (c *Controller) Export(w http.ResponseWriter, r *http.Request) {
-	opmlHandler := opml.NewHandler(c.store)
-	opml, err := opmlHandler.Export(context.New(r).UserID())
+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, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	xml.OK(w, opml)
+	xml.OK(w, r, opml)
 }
 
-// Import is the API handler that import an OPML file.
-func (c *Controller) Import(w http.ResponseWriter, r *http.Request) {
-	opmlHandler := opml.NewHandler(c.store)
-	err := opmlHandler.Import(context.New(r).UserID(), r.Body)
+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, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.Created(w, map[string]string{"message": "Feeds imported successfully"})
+	json.Created(w, r, map[string]string{"message": "Feeds imported successfully"})
 }

api/payload.go

@@ -2,14 +2,14 @@
 // 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 {
@@ -24,17 +24,21 @@ type entriesResponse struct {
 }
 
 type feedCreation struct {
-	FeedURL    string `json:"feed_url"`
-	CategoryID int64  `json:"category_id"`
-	Username   string `json:"username"`
-	Password   string `json:"password"`
-	Crawler    bool   `json:"crawler"`
+	FeedURL      string `json:"feed_url"`
+	CategoryID   int64  `json:"category_id"`
+	UserAgent    string `json:"user_agent"`
+	Username     string `json:"username"`
+	Password     string `json:"password"`
+	Crawler      bool   `json:"crawler"`
+	ScraperRules string `json:"scraper_rules"`
+	RewriteRules string `json:"rewrite_rules"`
 }
 
 type subscriptionDiscovery struct {
-	URL      string `json:"url"`
-	Username string `json:"username"`
-	Password string `json:"password"`
+	URL       string `json:"url"`
+	UserAgent string `json:"user_agent"`
+	Username  string `json:"username"`
+	Password  string `json:"password"`
 }
 
 type feedModification struct {
@@ -44,9 +48,11 @@ type feedModification struct {
 	ScraperRules *string `json:"scraper_rules"`
 	RewriteRules *string `json:"rewrite_rules"`
 	Crawler      *bool   `json:"crawler"`
+	UserAgent    *string `json:"user_agent"`
 	Username     *string `json:"username"`
 	Password     *string `json:"password"`
 	CategoryID   *int64  `json:"category_id"`
+	Disabled     *bool   `json:"disabled"`
 }
 
 func (f *feedModification) Update(feed *model.Feed) {
@@ -74,6 +80,10 @@ func (f *feedModification) Update(feed *model.Feed) {
 		feed.Crawler = *f.Crawler
 	}
 
+	if f.UserAgent != nil {
+		feed.UserAgent = *f.UserAgent
+	}
+
 	if f.Username != nil {
 		feed.Username = *f.Username
 	}
@@ -85,6 +95,10 @@ func (f *feedModification) Update(feed *model.Feed) {
 	if f.CategoryID != nil && *f.CategoryID > 0 {
 		feed.Category.ID = *f.CategoryID
 	}
+
+	if f.Disabled != nil {
+		feed.Disabled = *f.Disabled
+	}
 }
 
 type userModification struct {

api/payload_test.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 api
+package api // import "miniflux.app/api"
 
 import (
 	"testing"
 
-	"github.com/miniflux/miniflux/model"
+	"miniflux.app/model"
 )
 
 func TestUpdateFeedURL(t *testing.T) {
@@ -138,6 +138,33 @@ func TestUpdateFeedUsernameWhenNotSet(t *testing.T) {
 	}
 }
 
+func TestUpdateFeedDisabled(t *testing.T) {
+	valueTrue := true
+	valueFalse := false
+	scenarios := []struct {
+		changes  *feedModification
+		feed     *model.Feed
+		expected bool
+	}{
+		{&feedModification{}, &model.Feed{Disabled: true}, true},
+		{&feedModification{Disabled: &valueTrue}, &model.Feed{Disabled: true}, true},
+		{&feedModification{Disabled: &valueFalse}, &model.Feed{Disabled: true}, false},
+		{&feedModification{}, &model.Feed{Disabled: false}, false},
+		{&feedModification{Disabled: &valueTrue}, &model.Feed{Disabled: false}, true},
+		{&feedModification{Disabled: &valueFalse}, &model.Feed{Disabled: false}, false},
+	}
+
+	for _, scenario := range scenarios {
+		scenario.changes.Update(scenario.feed)
+		if scenario.feed.Disabled != scenario.expected {
+			t.Errorf(`Unexpected result, got %v, want: %v`,
+				scenario.feed.Disabled,
+				scenario.expected,
+			)
+		}
+	}
+}
+
 func TestUpdateFeedCategory(t *testing.T) {
 	categoryID := int64(1)
 	changes := &feedModification{CategoryID: &categoryID}

api/subscription.go

@@ -2,39 +2,37 @@
 // 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"
 	"net/http"
 
-	"github.com/miniflux/miniflux/http/response/json"
-	"github.com/miniflux/miniflux/reader/subscription"
+	"miniflux.app/http/response/json"
+	"miniflux.app/reader/subscription"
 )
 
-// GetSubscriptions is the API handler to find subscriptions.
-func (c *Controller) GetSubscriptions(w http.ResponseWriter, r *http.Request) {
-	subscriptionInfo, err := decodeURLPayload(r.Body)
-	if err != nil {
-		json.BadRequest(w, err)
+func (h *handler) getSubscriptions(w http.ResponseWriter, r *http.Request) {
+	subscriptionInfo, bodyErr := decodeURLPayload(r.Body)
+	if bodyErr != nil {
+		json.BadRequest(w, r, bodyErr)
 		return
 	}
 
-	subscriptions, err := subscription.FindSubscriptions(
+	subscriptions, finderErr := subscription.FindSubscriptions(
 		subscriptionInfo.URL,
+		subscriptionInfo.UserAgent,
 		subscriptionInfo.Username,
 		subscriptionInfo.Password,
 	)
-	if err != nil {
-		json.ServerError(w, errors.New("Unable to discover subscriptions"))
+	if finderErr != nil {
+		json.ServerError(w, r, finderErr)
 		return
 	}
 
 	if subscriptions == nil {
-		json.NotFound(w, fmt.Errorf("No subscription found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	json.OK(w, subscriptions)
+	json.OK(w, r, subscriptions)
 }

api/user.go

@@ -2,207 +2,177 @@
 // 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/context"
-	"github.com/miniflux/miniflux/http/request"
-	"github.com/miniflux/miniflux/http/response/json"
+	"miniflux.app/http/request"
+	"miniflux.app/http/response/json"
 )
 
-// CurrentUser is the API handler to retrieve the authenticated user.
-func (c *Controller) CurrentUser(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	user, err := c.store.UserByID(ctx.UserID())
+func (h *handler) currentUser(w http.ResponseWriter, r *http.Request) {
+	user, err := h.store.UserByID(request.UserID(r))
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.OK(w, user)
+	json.OK(w, r, user)
 }
 
-// CreateUser is the API handler to create a new user.
-func (c *Controller) CreateUser(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	if !ctx.IsAdminUser() {
-		json.Forbidden(w)
+func (h *handler) createUser(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
 	user, err := decodeUserCreationPayload(r.Body)
 	if err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
 	if err := user.ValidateUserCreation(); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	if c.store.UserExists(user.Username) {
-		json.BadRequest(w, errors.New("This user already exists"))
+	if h.store.UserExists(user.Username) {
+		json.BadRequest(w, r, errors.New("This user already exists"))
 		return
 	}
 
-	err = c.store.CreateUser(user)
+	err = h.store.CreateUser(user)
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to create this user"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	user.Password = ""
-	json.Created(w, user)
+	json.Created(w, r, user)
 }
 
-// UpdateUser is the API handler to update the given user.
-func (c *Controller) UpdateUser(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	if !ctx.IsAdminUser() {
-		json.Forbidden(w)
-		return
-	}
-
-	userID, err := request.IntParam(r, "userID")
-	if err != nil {
-		json.BadRequest(w, err)
+func (h *handler) updateUser(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
+	userID := request.RouteInt64Param(r, "userID")
 	userChanges, err := decodeUserModificationPayload(r.Body)
 	if err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	originalUser, err := c.store.UserByID(userID)
+	originalUser, err := h.store.UserByID(userID)
 	if err != nil {
-		json.BadRequest(w, 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 originalUser == nil {
-		json.NotFound(w, errors.New("User not found"))
+		json.NotFound(w, r)
 		return
 	}
 
 	userChanges.Update(originalUser)
 	if err := originalUser.ValidateUserModification(); err != nil {
-		json.BadRequest(w, err)
+		json.BadRequest(w, r, err)
 		return
 	}
 
-	if err = c.store.UpdateUser(originalUser); err != nil {
-		json.ServerError(w, errors.New("Unable to update this user"))
+	if err = h.store.UpdateUser(originalUser); err != nil {
+		json.ServerError(w, r, err)
 		return
 	}
 
-	json.Created(w, originalUser)
+	json.Created(w, r, originalUser)
 }
 
-// Users is the API handler to get the list of users.
-func (c *Controller) Users(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	if !ctx.IsAdminUser() {
-		json.Forbidden(w)
+func (h *handler) users(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	users, err := c.store.Users()
+	users, err := h.store.Users()
 	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch the list of users"))
+		json.ServerError(w, r, err)
 		return
 	}
 
-	users.UseTimezone(ctx.UserTimezone())
-	json.OK(w, users)
+	users.UseTimezone(request.UserTimezone(r))
+	json.OK(w, r, users)
 }
 
-// UserByID is the API handler to fetch the given user by the ID.
-func (c *Controller) UserByID(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	if !ctx.IsAdminUser() {
-		json.Forbidden(w)
+func (h *handler) userByID(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	userID, err := request.IntParam(r, "userID")
+	userID := request.RouteInt64Param(r, "userID")
+	user, err := h.store.UserByID(userID)
 	if err != nil {
-		json.BadRequest(w, err)
-		return
-	}
-
-	user, err := c.store.UserByID(userID)
-	if err != nil {
-		json.BadRequest(w, 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 {
-		json.NotFound(w, errors.New("User not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	user.UseTimezone(ctx.UserTimezone())
-	json.OK(w, 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(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	if !ctx.IsAdminUser() {
-		json.Forbidden(w)
+func (h *handler) userByUsername(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	username := request.Param(r, "username", "")
-	user, err := c.store.UserByUsername(username)
+	username := request.RouteStringParam(r, "username")
+	user, err := h.store.UserByUsername(username)
 	if err != nil {
-		json.BadRequest(w, 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 {
-		json.NotFound(w, errors.New("User not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	json.OK(w, user)
+	json.OK(w, r, user)
 }
 
-// RemoveUser is the API handler to remove an existing user.
-func (c *Controller) RemoveUser(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	if !ctx.IsAdminUser() {
-		json.Forbidden(w)
+func (h *handler) removeUser(w http.ResponseWriter, r *http.Request) {
+	if !request.IsAdminUser(r) {
+		json.Forbidden(w, r)
 		return
 	}
 
-	userID, err := request.IntParam(r, "userID")
+	userID := request.RouteInt64Param(r, "userID")
+	user, err := h.store.UserByID(userID)
 	if err != nil {
-		json.BadRequest(w, err)
-		return
-	}
-
-	user, err := c.store.UserByID(userID)
-	if err != nil {
-		json.ServerError(w, errors.New("Unable to fetch this user from the database"))
+		json.ServerError(w, r, err)
 		return
 	}
 
 	if user == nil {
-		json.NotFound(w, errors.New("User not found"))
+		json.NotFound(w, r)
 		return
 	}
 
-	if err := c.store.RemoveUser(user.ID); err != nil {
-		json.BadRequest(w, errors.New("Unable to remove this user from the database"))
+	if err := h.store.RemoveUser(user.ID); err != nil {
+		json.BadRequest(w, r, errors.New("Unable to remove this user from the database"))
 		return
 	}
 
-	json.NoContent(w)
+	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,86 +2,154 @@
 // 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/config"
-	"github.com/miniflux/miniflux/daemon"
-	"github.com/miniflux/miniflux/logger"
-	"github.com/miniflux/miniflux/storage"
-	"github.com/miniflux/miniflux/version"
+	"miniflux.app/config"
+	"miniflux.app/database"
+	"miniflux.app/logger"
+	"miniflux.app/storage"
+	"miniflux.app/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"
 )
 
 // 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")
-	flagResetFeedErrors := flag.Bool("reset-feed-errors", false, "Clear all feed errors for all users")
-	flagDebugMode := flag.Bool("debug", false, "Enable debug mode (more verbose output)")
+	var (
+		err                 error
+		flagInfo            bool
+		flagVersion         bool
+		flagMigrate         bool
+		flagFlushSessions   bool
+		flagCreateAdmin     bool
+		flagResetPassword   bool
+		flagResetFeedErrors bool
+		flagDebugMode       bool
+		flagConfigFile      string
+		flagConfigDump      bool
+	)
+
+	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.Parse()
 
-	cfg := config.NewConfig()
+	cfg := config.NewParser()
 
-	if *flagDebugMode || cfg.HasDebugMode() {
+	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()
 	}
 
-	store := storage.NewStorage(
-		cfg.DatabaseURL(),
-		cfg.DatabaseMaxConnections(),
-	)
-
-	if *flagInfo {
+	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")
+	}
+
+	db, err := database.NewConnectionPool(
+		config.Opts.DatabaseURL(),
+		config.Opts.DatabaseMinConns(),
+		config.Opts.DatabaseMaxConns(),
+	)
+	if err != nil {
+		logger.Fatal("Unable to connect to the database: %v", err)
+	}
+	defer db.Close()
+
+	if flagMigrate {
+		database.Migrate(db)
 		return
 	}
 
-	if *flagResetFeedErrors {
+	store := storage.NewStorage(db)
+
+	if flagResetFeedErrors {
 		store.ResetFeedErrors()
 		return
 	}
 
-	if *flagFlushSessions {
+	if flagFlushSessions {
 		flushSessions(store)
 		return
 	}
 
-	if *flagCreateAdmin {
+	if flagCreateAdmin {
 		createAdmin(store)
 		return
 	}
 
-	if *flagResetPassword {
+	if flagResetPassword {
 		resetPassword(store)
 		return
 	}
 
 	// Run migrations and start the deamon.
-	if cfg.RunMigrations() {
-		store.Migrate()
+	if config.Opts.RunMigrations() {
+		database.Migrate(db)
+	}
+
+	if err := database.IsSchemaUpToDate(db); err != nil {
+		logger.Fatal(`You must run the SQL migrations, %v`, err)
 	}
 
 	// Create admin user and start the deamon.
-	if cfg.CreateAdmin() {
+	if config.Opts.CreateAdmin() {
 		createAdmin(store)
 	}
 
-	daemon.Run(cfg, store)
+	startDaemon(store)
 }

cli/create_admin.go

@@ -2,14 +2,15 @@
 // 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/logger"
+	"miniflux.app/model"
+	"miniflux.app/storage"
 )
 
 func createAdmin(store *storage.Storage) {
@@ -23,12 +24,17 @@ func createAdmin(store *storage.Storage) {
 	}
 
 	if err := user.ValidateUserCreation(); err != nil {
-		fmt.Println(err)
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 
+	if store.UserExists(user.Username) {
+		logger.Info(`User %q already exists, skipping creation`, user.Username)
+		return
+	}
+
 	if err := store.CreateUser(user); err != nil {
-		fmt.Println(err)
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		os.Exit(1)
 	}
 }

cli/daemon.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 cli // import "miniflux.app/cli"
+
+import (
+	"context"
+	"net/http"
+	"os"
+	"os/signal"
+	"runtime"
+	"syscall"
+	"time"
+
+	"miniflux.app/config"
+	"miniflux.app/logger"
+	"miniflux.app/reader/feed"
+	"miniflux.app/service/httpd"
+	"miniflux.app/service/scheduler"
+	"miniflux.app/storage"
+	"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)
+
+	feedHandler := feed.NewFeedHandler(store)
+	pool := worker.NewPool(feedHandler, config.Opts.WorkerPoolSize())
+
+	go showProcessStatistics()
+
+	if config.Opts.HasSchedulerService() {
+		scheduler.Serve(store, pool)
+	}
+
+	var httpServer *http.Server
+	if config.Opts.HasHTTPService() {
+		httpServer = httpd.Serve(store, pool, feedHandler)
+	}
+
+	<-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")
+}
+
+func showProcessStatistics() {
+	for {
+		var m runtime.MemStats
+		runtime.ReadMemStats(&m)
+		logger.Debug("Sys=%vK, InUse=%vK, HeapInUse=%vK, StackSys=%vK, StackInUse=%vK, GoRoutines=%d, NumCPU=%d",
+			m.Sys/1024, (m.Sys-m.HeapReleased)/1024, m.HeapInuse/1024, m.StackSys/1024, m.StackInuse/1024,
+			runtime.NumGoroutine(), runtime.NumCPU())
+		time.Sleep(30 * time.Second)
+	}
+}

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/info.go

@@ -2,17 +2,20 @@
 // 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("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,36 @@
 // 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 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)
 	}
 
 	user.Password = password
 	if err := user.ValidatePassword(); err != nil {
-		fmt.Println(err)
+		fmt.Fprintf(os.Stderr, "%v\n", 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,54 @@
+Miniflux API Client
+===================
+
+Client library for Miniflux REST API.
+
+Installation
+------------
+
+```bash
+go get -u miniflux.app/client
+```
+
+Example
+-------
+
+```go
+package main
+
+import (
+	"fmt"
+    "io/ioutil"
+
+	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 = ioutil.WriteFile("opml.xml", opml, 0644)
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+}
+```

client/client.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 (
 	"encoding/json"
@@ -13,11 +13,19 @@ import (
 	"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")
@@ -312,7 +320,17 @@ func (c *Client) UpdateFeed(feedID int64, feedChanges *FeedModification) (*Feed,
 	return f, nil
 }
 
-// RefreshFeed refresh a feed.
+// RefreshAllFeeds refreshes all feeds.
+func (c *Client) RefreshAllFeeds() error {
+	body, err := c.request.Put(fmt.Sprintf("/v1/feeds/refresh"), nil)
+	if err != nil {
+		return err
+	}
+	body.Close()
+	return nil
+}
+
+// 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 {
@@ -448,11 +466,6 @@ func (c *Client) ToggleBookmark(entryID int64) error {
 	return nil
 }
 
-// NewClient returns a new Client.
-func NewClient(endpoint, username, password string) *Client {
-	return &Client{request: &request{endpoint: endpoint, username: username, password: password}}
-}
-
 func buildFilterQueryString(path string, filter *Filter) string {
 	if filter != nil {
 		values := url.Values{}
@@ -497,6 +510,10 @@ func buildFilterQueryString(path string, filter *Filter) string {
 			values.Set("starred", "1")
 		}
 
+		if filter.Search != "" {
+			values.Set("search", filter.Search)
+		}
+
 		path = fmt.Sprintf("%s?%s", path, values.Encode())
 	}
 

client/core.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 (
 	"fmt"
@@ -48,7 +48,7 @@ type UserModification struct {
 // Users represents a list of users.
 type Users []User
 
-// Category represents a category in the system.
+// Category represents a feed category.
 type Category struct {
 	ID     int64  `json:"id,omitempty"`
 	Title  string `json:"title,omitempty"`
@@ -91,10 +91,10 @@ type Feed struct {
 	ScraperRules       string    `json:"scraper_rules"`
 	RewriteRules       string    `json:"rewrite_rules"`
 	Crawler            bool      `json:"crawler"`
+	UserAgent          string    `json:"user_agent"`
 	Username           string    `json:"username"`
 	Password           string    `json:"password"`
 	Category           *Category `json:"category,omitempty"`
-	Entries            Entries   `json:"entries,omitempty"`
 }
 
 // FeedModification represents changes for a feed.
@@ -105,6 +105,7 @@ type FeedModification struct {
 	ScraperRules *string `json:"scraper_rules"`
 	RewriteRules *string `json:"rewrite_rules"`
 	Crawler      *bool   `json:"crawler"`
+	UserAgent    *string `json:"user_agent"`
 	Username     *string `json:"username"`
 	Password     *string `json:"password"`
 	CategoryID   *int64  `json:"category_id"`
@@ -132,10 +133,10 @@ type Entry struct {
 	Date       time.Time  `json:"published_at"`
 	Content    string     `json:"content"`
 	Author     string     `json:"author"`
+	ShareCode  string     `json:"share_code"`
 	Starred    bool       `json:"starred"`
 	Enclosures Enclosures `json:"enclosures,omitempty"`
 	Feed       *Feed      `json:"feed,omitempty"`
-	Category   *Category  `json:"category,omitempty"`
 }
 
 // Entries represents a list of entries.
@@ -166,6 +167,8 @@ type Filter struct {
 	After         int64
 	BeforeEntryID int64
 	AfterEntryID  int64
+	Search        string
+	CategoryID    int64
 }
 
 // EntryResultSet represents the response when fetching entries.

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/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"
@@ -18,7 +18,7 @@ import (
 )
 
 const (
-	userAgent      = "Miniflux Client Library <https://github.com/miniflux/miniflux-go>"
+	userAgent      = "Miniflux Client Library"
 	defaultTimeout = 80
 )
 
@@ -38,6 +38,7 @@ type request struct {
 	endpoint string
 	username string
 	password string
+	apiKey   string
 }
 
 func (r *request) Get(path string) (io.ReadCloser, error) {
@@ -75,7 +76,10 @@ 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 {
 		switch data.(type) {
@@ -131,6 +135,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,208 +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"
-
-	"github.com/miniflux/miniflux/logger"
-)
-
-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"
-	defaultCleanupFrequency = 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 {
-	value, exists := os.LookupEnv("DATABASE_URL")
-	if !exists {
-		logger.Info("The environment variable DATABASE_URL is not configured (the default value is used instead)")
-	}
-
-	if value == "" {
-		value = defaultDatabaseURL
-	}
-
-	return value
-}
-
-// 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 {
-	if port := os.Getenv("PORT"); port != "" {
-		return ":" + port
-	}
-
-	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)
-}
-
-// CleanupFrequency returns the interval for cleanup jobs.
-func (c *Config) CleanupFrequency() int {
-	return c.getInt("CLEANUP_FREQUENCY", defaultCleanupFrequency)
-}
-
-// 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", "") == ""
-}
-
-// RunMigrations returns true if the environment variable RUN_MIGRATIONS is not empty.
-func (c *Config) RunMigrations() bool {
-	return c.get("RUN_MIGRATIONS", "") != ""
-}
-
-// CreateAdmin returns true if the environment variable CREATE_ADMIN is not empty.
-func (c *Config) CreateAdmin() bool {
-	return c.get("CREATE_ADMIN", "") != ""
-}
-
-// PocketConsumerKey returns the Pocket Consumer Key if defined as environment variable.
-func (c *Config) PocketConsumerKey(defaultValue string) string {
-	return c.get("POCKET_CONSUMER_KEY", defaultValue)
-}
-
-// 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,393 @@
+// 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"
+	"strings"
+)
+
+const (
+	defaultHTTPS                              = false
+	defaultLogDateTime                        = false
+	defaultHSTS                               = true
+	defaultHTTPService                        = true
+	defaultSchedulerService                   = true
+	defaultDebug                              = false
+	defaultBaseURL                            = "http://localhost"
+	defaultRootURL                            = "http://localhost"
+	defaultBasePath                           = ""
+	defaultWorkerPoolSize                     = 5
+	defaultPollingFrequency                   = 60
+	defaultBatchSize                          = 10
+	defaultPollingScheduler                   = "round_robin"
+	defaultSchedulerEntryFrequencyMinInterval = 5
+	defaultSchedulerEntryFrequencyMaxInterval = 24 * 60
+	defaultRunMigrations                      = false
+	defaultDatabaseURL                        = "user=postgres password=postgres dbname=miniflux2 sslmode=disable"
+	defaultDatabaseMaxConns                   = 20
+	defaultDatabaseMinConns                   = 1
+	defaultListenAddr                         = "127.0.0.1:8080"
+	defaultCertFile                           = ""
+	defaultKeyFile                            = ""
+	defaultCertDomain                         = ""
+	defaultCertCache                          = "/tmp/cert_cache"
+	defaultCleanupFrequencyHours              = 24
+	defaultCleanupArchiveReadDays             = 60
+	defaultCleanupRemoveSessionsDays          = 30
+	defaultProxyImages                        = "http-only"
+	defaultCreateAdmin                        = false
+	defaultOAuth2UserCreation                 = false
+	defaultOAuth2ClientID                     = ""
+	defaultOAuth2ClientSecret                 = ""
+	defaultOAuth2RedirectURL                  = ""
+	defaultOAuth2OidcDiscoveryEndpoint        = ""
+	defaultOAuth2Provider                     = ""
+	defaultPocketConsumerKey                  = ""
+	defaultHTTPClientTimeout                  = 20
+	defaultHTTPClientMaxBodySize              = 15
+	defaultAuthProxyHeader                    = ""
+	defaultAuthProxyUserCreation              = false
+)
+
+// Options contains configuration options.
+type Options struct {
+	HTTPS                              bool
+	logDateTime                        bool
+	hsts                               bool
+	httpService                        bool
+	schedulerService                   bool
+	debug                              bool
+	baseURL                            string
+	rootURL                            string
+	basePath                           string
+	databaseURL                        string
+	databaseMaxConns                   int
+	databaseMinConns                   int
+	runMigrations                      bool
+	listenAddr                         string
+	certFile                           string
+	certDomain                         string
+	certCache                          string
+	certKeyFile                        string
+	cleanupFrequencyHours              int
+	cleanupArchiveReadDays             int
+	cleanupRemoveSessionsDays          int
+	pollingFrequency                   int
+	batchSize                          int
+	pollingScheduler                   string
+	schedulerEntryFrequencyMinInterval int
+	schedulerEntryFrequencyMaxInterval int
+	workerPoolSize                     int
+	createAdmin                        bool
+	proxyImages                        string
+	oauth2UserCreationAllowed          bool
+	oauth2ClientID                     string
+	oauth2ClientSecret                 string
+	oauth2RedirectURL                  string
+	oauth2OidcDiscoveryEndpoint        string
+	oauth2Provider                     string
+	pocketConsumerKey                  string
+	httpClientTimeout                  int
+	httpClientMaxBodySize              int64
+	authProxyHeader                    string
+	authProxyUserCreation              bool
+}
+
+// NewOptions returns Options with default values.
+func NewOptions() *Options {
+	return &Options{
+		HTTPS:                              defaultHTTPS,
+		logDateTime:                        defaultLogDateTime,
+		hsts:                               defaultHSTS,
+		httpService:                        defaultHTTPService,
+		schedulerService:                   defaultSchedulerService,
+		debug:                              defaultDebug,
+		baseURL:                            defaultBaseURL,
+		rootURL:                            defaultRootURL,
+		basePath:                           defaultBasePath,
+		databaseURL:                        defaultDatabaseURL,
+		databaseMaxConns:                   defaultDatabaseMaxConns,
+		databaseMinConns:                   defaultDatabaseMinConns,
+		runMigrations:                      defaultRunMigrations,
+		listenAddr:                         defaultListenAddr,
+		certFile:                           defaultCertFile,
+		certDomain:                         defaultCertDomain,
+		certCache:                          defaultCertCache,
+		certKeyFile:                        defaultKeyFile,
+		cleanupFrequencyHours:              defaultCleanupFrequencyHours,
+		cleanupArchiveReadDays:             defaultCleanupArchiveReadDays,
+		cleanupRemoveSessionsDays:          defaultCleanupRemoveSessionsDays,
+		pollingFrequency:                   defaultPollingFrequency,
+		batchSize:                          defaultBatchSize,
+		pollingScheduler:                   defaultPollingScheduler,
+		schedulerEntryFrequencyMinInterval: defaultSchedulerEntryFrequencyMinInterval,
+		schedulerEntryFrequencyMaxInterval: defaultSchedulerEntryFrequencyMaxInterval,
+		workerPoolSize:                     defaultWorkerPoolSize,
+		createAdmin:                        defaultCreateAdmin,
+		proxyImages:                        defaultProxyImages,
+		oauth2UserCreationAllowed:          defaultOAuth2UserCreation,
+		oauth2ClientID:                     defaultOAuth2ClientID,
+		oauth2ClientSecret:                 defaultOAuth2ClientSecret,
+		oauth2RedirectURL:                  defaultOAuth2RedirectURL,
+		oauth2OidcDiscoveryEndpoint:        defaultOAuth2OidcDiscoveryEndpoint,
+		oauth2Provider:                     defaultOAuth2Provider,
+		pocketConsumerKey:                  defaultPocketConsumerKey,
+		httpClientTimeout:                  defaultHTTPClientTimeout,
+		httpClientMaxBodySize:              defaultHTTPClientMaxBodySize * 1024 * 1024,
+		authProxyHeader:                    defaultAuthProxyHeader,
+		authProxyUserCreation:              defaultAuthProxyUserCreation,
+	}
+}
+
+// LogDateTime returns true if the date/time should be displayed in log messages.
+func (o *Options) LogDateTime() bool {
+	return o.logDateTime
+}
+
+// HasDebugMode returns true if debug mode is enabled.
+func (o *Options) HasDebugMode() bool {
+	return o.debug
+}
+
+// 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
+}
+
+// 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
+}
+
+// CertCache returns the directory to use for Let's Encrypt session cache.
+func (o *Options) CertCache() string {
+	return o.certCache
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+func (o *Options) String() string {
+	var builder strings.Builder
+	builder.WriteString(fmt.Sprintf("LOG_DATE_TIME: %v\n", o.logDateTime))
+	builder.WriteString(fmt.Sprintf("DEBUG: %v\n", o.debug))
+	builder.WriteString(fmt.Sprintf("HTTP_SERVICE: %v\n", o.httpService))
+	builder.WriteString(fmt.Sprintf("SCHEDULER_SERVICE: %v\n", o.schedulerService))
+	builder.WriteString(fmt.Sprintf("HTTPS: %v\n", o.HTTPS))
+	builder.WriteString(fmt.Sprintf("HSTS: %v\n", o.hsts))
+	builder.WriteString(fmt.Sprintf("BASE_URL: %v\n", o.baseURL))
+	builder.WriteString(fmt.Sprintf("ROOT_URL: %v\n", o.rootURL))
+	builder.WriteString(fmt.Sprintf("BASE_PATH: %v\n", o.basePath))
+	builder.WriteString(fmt.Sprintf("LISTEN_ADDR: %v\n", o.listenAddr))
+	builder.WriteString(fmt.Sprintf("DATABASE_URL: %v\n", o.databaseURL))
+	builder.WriteString(fmt.Sprintf("DATABASE_MAX_CONNS: %v\n", o.databaseMaxConns))
+	builder.WriteString(fmt.Sprintf("DATABASE_MIN_CONNS: %v\n", o.databaseMinConns))
+	builder.WriteString(fmt.Sprintf("RUN_MIGRATIONS: %v\n", o.runMigrations))
+	builder.WriteString(fmt.Sprintf("CERT_FILE: %v\n", o.certFile))
+	builder.WriteString(fmt.Sprintf("KEY_FILE: %v\n", o.certKeyFile))
+	builder.WriteString(fmt.Sprintf("CERT_DOMAIN: %v\n", o.certDomain))
+	builder.WriteString(fmt.Sprintf("CERT_CACHE: %v\n", o.certCache))
+	builder.WriteString(fmt.Sprintf("CLEANUP_FREQUENCY_HOURS: %v\n", o.cleanupFrequencyHours))
+	builder.WriteString(fmt.Sprintf("CLEANUP_ARCHIVE_READ_DAYS: %v\n", o.cleanupArchiveReadDays))
+	builder.WriteString(fmt.Sprintf("CLEANUP_REMOVE_SESSIONS_DAYS: %v\n", o.cleanupRemoveSessionsDays))
+	builder.WriteString(fmt.Sprintf("WORKER_POOL_SIZE: %v\n", o.workerPoolSize))
+	builder.WriteString(fmt.Sprintf("POLLING_FREQUENCY: %v\n", o.pollingFrequency))
+	builder.WriteString(fmt.Sprintf("BATCH_SIZE: %v\n", o.batchSize))
+	builder.WriteString(fmt.Sprintf("POLLING_SCHEDULER: %v\n", o.pollingScheduler))
+	builder.WriteString(fmt.Sprintf("SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL: %v\n", o.schedulerEntryFrequencyMaxInterval))
+	builder.WriteString(fmt.Sprintf("SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL: %v\n", o.schedulerEntryFrequencyMinInterval))
+	builder.WriteString(fmt.Sprintf("PROXY_IMAGES: %v\n", o.proxyImages))
+	builder.WriteString(fmt.Sprintf("CREATE_ADMIN: %v\n", o.createAdmin))
+	builder.WriteString(fmt.Sprintf("POCKET_CONSUMER_KEY: %v\n", o.pocketConsumerKey))
+	builder.WriteString(fmt.Sprintf("OAUTH2_USER_CREATION: %v\n", o.oauth2UserCreationAllowed))
+	builder.WriteString(fmt.Sprintf("OAUTH2_CLIENT_ID: %v\n", o.oauth2ClientID))
+	builder.WriteString(fmt.Sprintf("OAUTH2_CLIENT_SECRET: %v\n", o.oauth2ClientSecret))
+	builder.WriteString(fmt.Sprintf("OAUTH2_REDIRECT_URL: %v\n", o.oauth2RedirectURL))
+	builder.WriteString(fmt.Sprintf("OAUTH2_OIDC_DISCOVERY_ENDPOINT: %v\n", o.oauth2OidcDiscoveryEndpoint))
+	builder.WriteString(fmt.Sprintf("OAUTH2_PROVIDER: %v\n", o.oauth2Provider))
+	builder.WriteString(fmt.Sprintf("HTTP_CLIENT_TIMEOUT: %v\n", o.httpClientTimeout))
+	builder.WriteString(fmt.Sprintf("HTTP_CLIENT_MAX_BODY_SIZE: %v\n", o.httpClientMaxBodySize))
+	builder.WriteString(fmt.Sprintf("AUTH_PROXY_HEADER: %v\n", o.authProxyHeader))
+	builder.WriteString(fmt.Sprintf("AUTH_PROXY_USER_CREATION: %v\n", o.authProxyUserCreation))
+	return builder.String()
+}

config/parser.go

@@ -0,0 +1,237 @@
+// 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"
+	"errors"
+	"fmt"
+	"io"
+	url_parser "net/url"
+	"os"
+	"strconv"
+	"strings"
+
+	"miniflux.app/logger"
+)
+
+// 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 "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_MAX_CONNS":
+			p.opts.databaseMaxConns = parseInt(value, defaultDatabaseMaxConns)
+		case "DATABASE_MIN_CONNS":
+			p.opts.databaseMinConns = parseInt(value, defaultDatabaseMinConns)
+		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 "CERT_CACHE":
+			p.opts.certCache = parseString(value, defaultCertCache)
+		case "CLEANUP_FREQUENCY_HOURS":
+			p.opts.cleanupFrequencyHours = parseInt(value, defaultCleanupFrequencyHours)
+		case "CLEANUP_ARCHIVE_READ_DAYS":
+			p.opts.cleanupArchiveReadDays = parseInt(value, defaultCleanupArchiveReadDays)
+		case "CLEANUP_REMOVE_SESSIONS_DAYS":
+			p.opts.cleanupRemoveSessionsDays = parseInt(value, defaultCleanupRemoveSessionsDays)
+		case "CLEANUP_FREQUENCY":
+			logger.Error("[Config] CLEANUP_FREQUENCY has been deprecated in favor of CLEANUP_FREQUENCY_HOURS.")
+
+			if p.opts.cleanupFrequencyHours != defaultCleanupFrequencyHours {
+				logger.Error("[Config] Ignoring CLEANUP_FREQUENCY as CLEANUP_FREQUENCY_HOURS is already specified.")
+			} else {
+				p.opts.cleanupFrequencyHours = parseInt(value, defaultCleanupFrequencyHours)
+			}
+		case "ARCHIVE_READ_DAYS":
+			logger.Error("[Config] ARCHIVE_READ_DAYS has been deprecated in favor of CLEANUP_ARCHIVE_READ_DAYS.")
+
+			if p.opts.cleanupArchiveReadDays != defaultCleanupArchiveReadDays {
+				logger.Error("[Config] Ignoring ARCHIVE_READ_DAYS as CLEANUP_ARCHIVE_READ_DAYS is already specified.")
+			} else {
+				p.opts.cleanupArchiveReadDays = parseInt(value, defaultCleanupArchiveReadDays)
+			}
+		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 "PROXY_IMAGES":
+			p.opts.proxyImages = parseString(value, defaultProxyImages)
+		case "CREATE_ADMIN":
+			p.opts.createAdmin = parseBool(value, defaultCreateAdmin)
+		case "POCKET_CONSUMER_KEY":
+			p.opts.pocketConsumerKey = parseString(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_SECRET":
+			p.opts.oauth2ClientSecret = parseString(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 "AUTH_PROXY_HEADER":
+			p.opts.authProxyHeader = parseString(value, defaultAuthProxyHeader)
+		case "AUTH_PROXY_USER_CREATION":
+			p.opts.authProxyUserCreation = parseBool(value, defaultAuthProxyUserCreation)
+		}
+	}
+
+	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("Invalid BASE_URL: %v", err)
+	}
+
+	scheme := strings.ToLower(url.Scheme)
+	if scheme != "https" && scheme != "http" {
+		return "", "", "", errors.New("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
+}

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

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,64 +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"
-	"runtime"
-	"syscall"
-	"time"
-
-	"github.com/miniflux/miniflux/config"
-	"github.com/miniflux/miniflux/locale"
-	"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)
-
-	go func() {
-		for {
-			var m runtime.MemStats
-			runtime.ReadMemStats(&m)
-			logger.Debug("Sys=%vK, InUse=%vK, HeapInUse=%vK, StackSys=%vK, StackInUse=%vK, GoRoutines=%d, NumCPU=%d",
-				m.Sys/1024, (m.Sys-m.HeapReleased)/1024, m.HeapInuse/1024, m.StackSys/1024, m.StackInuse/1024,
-				runtime.NumGoroutine(), runtime.NumCPU())
-			time.Sleep(30 * time.Second)
-		}
-	}()
-
-	translator := locale.Load()
-	feedHandler := feed.NewFeedHandler(store, translator)
-	pool := scheduler.NewWorkerPool(feedHandler, cfg.WorkerPoolSize())
-	server := newServer(cfg, store, pool, feedHandler, translator)
-
-	scheduler.NewFeedScheduler(
-		store,
-		pool,
-		cfg.PollingFrequency(),
-		cfg.BatchSize(),
-	)
-
-	scheduler.NewCleanupScheduler(store, cfg.CleanupFrequency())
-
-	<-stop
-	logger.Info("Shutting down the server...")
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	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,151 +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/locale"
-	"github.com/miniflux/miniflux/middleware"
-	"github.com/miniflux/miniflux/reader/feed"
-	"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, translator *locale.Translator) *mux.Router {
-	router := mux.NewRouter()
-	templateEngine := template.NewEngine(cfg, router, translator)
-	apiController := api.NewController(store, feedHandler)
-	feverController := fever.NewController(cfg, store)
-	uiController := ui.NewController(cfg, store, pool, feedHandler, templateEngine, translator, router)
-	middleware := middleware.New(cfg, store, router)
-
-	if cfg.BasePath() != "" {
-		router = router.PathPrefix(cfg.BasePath()).Subrouter()
-	}
-
-	router.Use(middleware.HeaderConfig)
-	router.Use(middleware.Logging)
-	router.Use(middleware.CommonHeaders)
-
-	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: /"))
-	})
-
-	feverRouter := router.PathPrefix("/fever").Subrouter()
-	feverRouter.Use(middleware.FeverAuth)
-	feverRouter.HandleFunc("/", feverController.Handler).Name("feverEndpoint")
-
-	apiRouter := router.PathPrefix("/v1").Subrouter()
-	apiRouter.Use(middleware.BasicAuth)
-	apiRouter.HandleFunc("/users", apiController.CreateUser).Methods("POST")
-	apiRouter.HandleFunc("/users", apiController.Users).Methods("GET")
-	apiRouter.HandleFunc("/users/{userID:[0-9]+}", apiController.UserByID).Methods("GET")
-	apiRouter.HandleFunc("/users/{userID:[0-9]+}", apiController.UpdateUser).Methods("PUT")
-	apiRouter.HandleFunc("/users/{userID:[0-9]+}", apiController.RemoveUser).Methods("DELETE")
-	apiRouter.HandleFunc("/users/{username}", apiController.UserByUsername).Methods("GET")
-	apiRouter.HandleFunc("/me", apiController.CurrentUser).Methods("GET")
-	apiRouter.HandleFunc("/categories", apiController.CreateCategory).Methods("POST")
-	apiRouter.HandleFunc("/categories", apiController.GetCategories).Methods("GET")
-	apiRouter.HandleFunc("/categories/{categoryID}", apiController.UpdateCategory).Methods("PUT")
-	apiRouter.HandleFunc("/categories/{categoryID}", apiController.RemoveCategory).Methods("DELETE")
-	apiRouter.HandleFunc("/discover", apiController.GetSubscriptions).Methods("POST")
-	apiRouter.HandleFunc("/feeds", apiController.CreateFeed).Methods("POST")
-	apiRouter.HandleFunc("/feeds", apiController.GetFeeds).Methods("GET")
-	apiRouter.HandleFunc("/feeds/{feedID}/refresh", apiController.RefreshFeed).Methods("PUT")
-	apiRouter.HandleFunc("/feeds/{feedID}", apiController.GetFeed).Methods("GET")
-	apiRouter.HandleFunc("/feeds/{feedID}", apiController.UpdateFeed).Methods("PUT")
-	apiRouter.HandleFunc("/feeds/{feedID}", apiController.RemoveFeed).Methods("DELETE")
-	apiRouter.HandleFunc("/feeds/{feedID}/icon", apiController.FeedIcon).Methods("GET")
-	apiRouter.HandleFunc("/export", apiController.Export).Methods("GET")
-	apiRouter.HandleFunc("/import", apiController.Import).Methods("POST")
-	apiRouter.HandleFunc("/feeds/{feedID}/entries", apiController.GetFeedEntries).Methods("GET")
-	apiRouter.HandleFunc("/feeds/{feedID}/entries/{entryID}", apiController.GetFeedEntry).Methods("GET")
-	apiRouter.HandleFunc("/entries", apiController.GetEntries).Methods("GET")
-	apiRouter.HandleFunc("/entries", apiController.SetEntryStatus).Methods("PUT")
-	apiRouter.HandleFunc("/entries/{entryID}", apiController.GetEntry).Methods("GET")
-	apiRouter.HandleFunc("/entries/{entryID}/bookmark", apiController.ToggleBookmark).Methods("PUT")
-
-	uiRouter := router.NewRoute().Subrouter()
-	uiRouter.Use(middleware.AppSession)
-	uiRouter.Use(middleware.UserSession)
-	uiRouter.HandleFunc("/stylesheets/{name}.css", uiController.Stylesheet).Name("stylesheet").Methods("GET")
-	uiRouter.HandleFunc("/js", uiController.Javascript).Name("javascript").Methods("GET")
-	uiRouter.HandleFunc("/favicon.ico", uiController.Favicon).Name("favicon").Methods("GET")
-	uiRouter.HandleFunc("/icon/{filename}", uiController.AppIcon).Name("appIcon").Methods("GET")
-	uiRouter.HandleFunc("/manifest.json", uiController.WebManifest).Name("webManifest").Methods("GET")
-	uiRouter.HandleFunc("/subscribe", uiController.AddSubscription).Name("addSubscription").Methods("GET")
-	uiRouter.HandleFunc("/subscribe", uiController.SubmitSubscription).Name("submitSubscription").Methods("POST")
-	uiRouter.HandleFunc("/subscriptions", uiController.ChooseSubscription).Name("chooseSubscription").Methods("POST")
-	uiRouter.HandleFunc("/mark-all-as-read", uiController.MarkAllAsRead).Name("markAllAsRead").Methods("GET")
-	uiRouter.HandleFunc("/unread", uiController.ShowUnreadPage).Name("unread").Methods("GET")
-	uiRouter.HandleFunc("/history", uiController.ShowHistoryPage).Name("history").Methods("GET")
-	uiRouter.HandleFunc("/starred", uiController.ShowStarredPage).Name("starred").Methods("GET")
-	uiRouter.HandleFunc("/feed/{feedID}/refresh", uiController.RefreshFeed).Name("refreshFeed").Methods("GET")
-	uiRouter.HandleFunc("/feed/{feedID}/edit", uiController.EditFeed).Name("editFeed").Methods("GET")
-	uiRouter.HandleFunc("/feed/{feedID}/remove", uiController.RemoveFeed).Name("removeFeed").Methods("POST")
-	uiRouter.HandleFunc("/feed/{feedID}/update", uiController.UpdateFeed).Name("updateFeed").Methods("POST")
-	uiRouter.HandleFunc("/feed/{feedID}/entries", uiController.ShowFeedEntries).Name("feedEntries").Methods("GET")
-	uiRouter.HandleFunc("/feeds", uiController.ShowFeedsPage).Name("feeds").Methods("GET")
-	uiRouter.HandleFunc("/feeds/refresh", uiController.RefreshAllFeeds).Name("refreshAllFeeds").Methods("GET")
-	uiRouter.HandleFunc("/unread/entry/{entryID}", uiController.ShowUnreadEntry).Name("unreadEntry").Methods("GET")
-	uiRouter.HandleFunc("/history/entry/{entryID}", uiController.ShowReadEntry).Name("readEntry").Methods("GET")
-	uiRouter.HandleFunc("/history/flush", uiController.FlushHistory).Name("flushHistory").Methods("GET")
-	uiRouter.HandleFunc("/feed/{feedID}/entry/{entryID}", uiController.ShowFeedEntry).Name("feedEntry").Methods("GET")
-	uiRouter.HandleFunc("/category/{categoryID}/entry/{entryID}", uiController.ShowCategoryEntry).Name("categoryEntry").Methods("GET")
-	uiRouter.HandleFunc("/starred/entry/{entryID}", uiController.ShowStarredEntry).Name("starredEntry").Methods("GET")
-	uiRouter.HandleFunc("/entry/status", uiController.UpdateEntriesStatus).Name("updateEntriesStatus").Methods("POST")
-	uiRouter.HandleFunc("/entry/save/{entryID}", uiController.SaveEntry).Name("saveEntry").Methods("POST")
-	uiRouter.HandleFunc("/entry/download/{entryID}", uiController.FetchContent).Name("fetchContent").Methods("POST")
-	uiRouter.HandleFunc("/entry/bookmark/{entryID}", uiController.ToggleBookmark).Name("toggleBookmark").Methods("POST")
-	uiRouter.HandleFunc("/categories", uiController.CategoryList).Name("categories").Methods("GET")
-	uiRouter.HandleFunc("/category/create", uiController.CreateCategory).Name("createCategory").Methods("GET")
-	uiRouter.HandleFunc("/category/save", uiController.SaveCategory).Name("saveCategory").Methods("POST")
-	uiRouter.HandleFunc("/category/{categoryID}/entries", uiController.CategoryEntries).Name("categoryEntries").Methods("GET")
-	uiRouter.HandleFunc("/category/{categoryID}/edit", uiController.EditCategory).Name("editCategory").Methods("GET")
-	uiRouter.HandleFunc("/category/{categoryID}/update", uiController.UpdateCategory).Name("updateCategory").Methods("POST")
-	uiRouter.HandleFunc("/category/{categoryID}/remove", uiController.RemoveCategory).Name("removeCategory").Methods("POST")
-	uiRouter.HandleFunc("/feed/icon/{iconID}", uiController.ShowIcon).Name("icon").Methods("GET")
-	uiRouter.HandleFunc("/proxy/{encodedURL}", uiController.ImageProxy).Name("proxy").Methods("GET")
-	uiRouter.HandleFunc("/users", uiController.ShowUsers).Name("users").Methods("GET")
-	uiRouter.HandleFunc("/user/create", uiController.CreateUser).Name("createUser").Methods("GET")
-	uiRouter.HandleFunc("/user/save", uiController.SaveUser).Name("saveUser").Methods("POST")
-	uiRouter.HandleFunc("/users/{userID}/edit", uiController.EditUser).Name("editUser").Methods("GET")
-	uiRouter.HandleFunc("/users/{userID}/update", uiController.UpdateUser).Name("updateUser").Methods("POST")
-	uiRouter.HandleFunc("/users/{userID}/remove", uiController.RemoveUser).Name("removeUser").Methods("POST")
-	uiRouter.HandleFunc("/about", uiController.About).Name("about").Methods("GET")
-	uiRouter.HandleFunc("/settings", uiController.ShowSettings).Name("settings").Methods("GET")
-	uiRouter.HandleFunc("/settings", uiController.UpdateSettings).Name("updateSettings").Methods("POST")
-	uiRouter.HandleFunc("/bookmarklet", uiController.Bookmarklet).Name("bookmarklet").Methods("GET")
-	uiRouter.HandleFunc("/integrations", uiController.ShowIntegrations).Name("integrations").Methods("GET")
-	uiRouter.HandleFunc("/integration", uiController.UpdateIntegration).Name("updateIntegration").Methods("POST")
-	uiRouter.HandleFunc("/integration/pocket/authorize", uiController.PocketAuthorize).Name("pocketAuthorize").Methods("GET")
-	uiRouter.HandleFunc("/integration/pocket/callback", uiController.PocketCallback).Name("pocketCallback").Methods("GET")
-	uiRouter.HandleFunc("/sessions", uiController.ShowSessions).Name("sessions").Methods("GET")
-	uiRouter.HandleFunc("/sessions/{sessionID}/remove", uiController.RemoveSession).Name("removeSession").Methods("POST")
-	uiRouter.HandleFunc("/export", uiController.Export).Name("export").Methods("GET")
-	uiRouter.HandleFunc("/import", uiController.Import).Name("import").Methods("GET")
-	uiRouter.HandleFunc("/upload", uiController.UploadOPML).Name("uploadOPML").Methods("POST")
-	uiRouter.HandleFunc("/oauth2/{provider}/unlink", uiController.OAuth2Unlink).Name("oauth2Unlink").Methods("GET")
-	uiRouter.HandleFunc("/oauth2/{provider}/redirect", uiController.OAuth2Redirect).Name("oauth2Redirect").Methods("GET")
-	uiRouter.HandleFunc("/oauth2/{provider}/callback", uiController.OAuth2Callback).Name("oauth2Callback").Methods("GET")
-	uiRouter.HandleFunc("/login", uiController.CheckLogin).Name("checkLogin").Methods("POST")
-	uiRouter.HandleFunc("/logout", uiController.Logout).Name("logout").Methods("GET")
-	uiRouter.HandleFunc("/", uiController.ShowLoginPage).Name("login").Methods("GET")
-
-	return router
-}

daemon/server.go

@@ -1,71 +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/locale"
-	"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, translator *locale.Translator) *http.Server {
-	certFile := cfg.CertFile()
-	keyFile := cfg.KeyFile()
-	certDomain := cfg.CertDomain()
-	certCache := cfg.CertCache()
-	server := &http.Server{
-		ReadTimeout:  30 * time.Second,
-		WriteTimeout: 30 * time.Second,
-		IdleTimeout:  60 * time.Second,
-		Addr:         cfg.ListenAddr(),
-		Handler:      routes(cfg, store, feedHandler, pool, translator),
-	}
-
-	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,25 @@
+// 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"
+
+	// Postgresql driver import
+	_ "github.com/lib/pq"
+)
+
+// NewConnectionPool configures the database connection pool.
+func NewConnectionPool(dsn string, minConnections, maxConnections int) (*sql.DB, error) {
+	db, err := sql.Open("postgres", dsn)
+	if err != nil {
+		return nil, err
+	}
+
+	db.SetMaxOpenConns(maxConnections)
+	db.SetMaxIdleConns(minConnections)
+
+	return db, nil
+}

database/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 database provides functions related to the database connection.
+
+*/
+package database // import "miniflux.app/database"

database/migration.go

@@ -0,0 +1,65 @@
+// 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"
+	"strconv"
+
+	"miniflux.app/logger"
+)
+
+const schemaVersion = 31
+
+// Migrate executes database migrations.
+func Migrate(db *sql.DB) {
+	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 + 1; version <= schemaVersion; version++ {
+		fmt.Println("Migrating to version:", version)
+
+		tx, err := db.Begin()
+		if err != nil {
+			logger.Fatal("[Migrate] %v", err)
+		}
+
+		rawSQL := SqlMap["schema_version_"+strconv.Itoa(version)]
+		// fmt.Println(rawSQL)
+		_, err = tx.Exec(rawSQL)
+		if err != nil {
+			tx.Rollback()
+			logger.Fatal("[Migrate] %v", err)
+		}
+
+		if _, err := tx.Exec(`delete from schema_version`); err != nil {
+			tx.Rollback()
+			logger.Fatal("[Migrate] %v", err)
+		}
+
+		if _, err := tx.Exec(`INSERT INTO schema_version (version) VALUES ($1)`, version); err != nil {
+			tx.Rollback()
+			logger.Fatal("[Migrate] %v", err)
+		}
+
+		if err := tx.Commit(); err != nil {
+			logger.Fatal("[Migrate] %v", err)
+		}
+	}
+}
+
+// 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/sql.go

@@ -1,7 +1,6 @@
 // Code generated by go generate; DO NOT EDIT.
-// 2018-06-19 22:56:40.283528941 -0700 PDT m=+0.005341061
 
-package sql
+package database // import "miniflux.app/database"
 
 var SqlMap = map[string]string{
 	"schema_version_1": `create table schema_version (
@@ -141,6 +140,38 @@ alter table feeds add column password text default '';`,
 	"schema_version_2": `create extension if not exists hstore;
 alter table users add column extra hstore;
 create index users_extra_idx on users using gin(extra);
+`,
+	"schema_version_20": `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);`,
+	"schema_version_21": `alter table feeds add column user_agent text default '';`,
+	"schema_version_22": `update entries set document_vectors = setweight(to_tsvector(substring(coalesce(title, '') for 1000000)), 'A') || setweight(to_tsvector(substring(coalesce(content, '') for 1000000)), 'B');`,
+	"schema_version_23": `alter table users add column keyboard_shortcuts boolean default 't';`,
+	"schema_version_24": `alter table feeds add column disabled boolean default 'f';`,
+	"schema_version_25": `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';
+`,
+	"schema_version_26": `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;
+`,
+	"schema_version_27": `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)
+);
+`,
+	"schema_version_28": `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 <> '';
+`,
+	"schema_version_29": `create index enclosures_user_entry_url_idx on enclosures(user_id, entry_id, md5(url));
 `,
 	"schema_version_3": `create table tokens (
     id text not null,
@@ -148,6 +179,10 @@ create index users_extra_idx on users using gin(extra);
     created_at timestamp with time zone not null default now(),
     primary key(id, value)
 );`,
+	"schema_version_30": `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);
+`,
+	"schema_version_31": `alter table feeds add column ignore_http_cache bool default false;`,
 	"schema_version_4": `create type entry_sorting_direction as enum('asc', 'desc');
 alter table users add column entry_direction entry_sorting_direction default 'asc';
 `,
@@ -189,7 +224,19 @@ var SqlMapChecksums = map[string]string{
 	"schema_version_18": "c0ec24847612c7f2dc326cf735baffba79391a56aedd73292371a39f38724a71",
 	"schema_version_19": "a83f77b41cc213d282805a5b518f15abbf96331599119f0ef4aca4be037add7b",
 	"schema_version_2":  "e8e9ff32478df04fcddad10a34cba2e8bb1e67e7977b5bd6cdc4c31ec94282b4",
+	"schema_version_20": "5d414c0cfc0da2863c641079afa58b7ff42dccb0f0e01c822ad435c3e3aa9201",
+	"schema_version_21": "77da01ee38918ff4fe33985fbb20ed3276a717a7584c2ca9ebcf4d4ab6cb6910",
+	"schema_version_22": "51ed5fbcae9877e57274511f0ef8c61d254ebd78dfbcbc043a2acd30f4c93ca3",
+	"schema_version_23": "cb3512d328436447f114e305048c0daa8af7505cfe5eab02778b0de1156081b2",
+	"schema_version_24": "1224754c5b9c6b4038599852bbe72656d21b09cb018d3970bd7c00f0019845bf",
+	"schema_version_25": "5262d2d4c88d637b6603a1fcd4f68ad257bd59bd1adf89c58a18ee87b12050d7",
+	"schema_version_26": "64f14add40691f18f514ac0eed10cd9b19c83a35e5c3d8e0bce667e0ceca9094",
+	"schema_version_27": "4235396b37fd7f52ff6f7526416042bb1649701233e2d99f0bcd583834a0a967",
+	"schema_version_28": "a64b5ba0b37fe3f209617b7d0e4dd05018d2b8362d2c9c528ba8cce19b77e326",
+	"schema_version_29": "527403d951d025b387baf7b1ab80c014752c5429cc0b9851aeb34b7716cf2c68",
 	"schema_version_3":  "a54745dbc1c51c000f74d4e5068f1e2f43e83309f023415b1749a47d5c1e0f12",
+	"schema_version_30": "3ec48a9b2e7a0fc32c85f31652f723565c34213f5f2d7e5e5076aad8f0b40d23",
+	"schema_version_31": "9290ef295731b03ddfe32dcaded0be70d41b63572420ad379cf2874a9b54581c",
 	"schema_version_4":  "216ea3a7d3e1704e40c797b5dc47456517c27dbb6ca98bf88812f4f63d74b5d9",
 	"schema_version_5":  "46397e2f5f2c82116786127e9f6a403e975b14d2ca7b652a48cd1ba843e6a27c",
 	"schema_version_6":  "9d05b4fb223f0e60efc716add5048b0ca9c37511cf2041721e20505d6d798ce4",

database/sql/schema_version_20.sql

@@ -0,0 +1,3 @@
+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);

database/sql/schema_version_21.sql

@@ -0,0 +1 @@
+alter table feeds add column user_agent text default '';

database/sql/schema_version_22.sql

@@ -0,0 +1 @@
+update entries set document_vectors = setweight(to_tsvector(substring(coalesce(title, '') for 1000000)), 'A') || setweight(to_tsvector(substring(coalesce(content, '') for 1000000)), 'B');

database/sql/schema_version_23.sql

@@ -0,0 +1 @@
+alter table users add column keyboard_shortcuts boolean default 't';

database/sql/schema_version_24.sql

@@ -0,0 +1 @@
+alter table feeds add column disabled boolean default 'f';

database/sql/schema_version_25.sql

@@ -0,0 +1,4 @@
+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';

database/sql/schema_version_26.sql

@@ -0,0 +1,3 @@
+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;

database/sql/schema_version_27.sql

@@ -0,0 +1,10 @@
+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)
+);

database/sql/schema_version_28.sql

@@ -0,0 +1,2 @@
+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 <> '';

database/sql/schema_version_29.sql

@@ -0,0 +1 @@
+create index enclosures_user_entry_url_idx on enclosures(user_id, entry_id, md5(url));

database/sql/schema_version_30.sql

@@ -0,0 +1,2 @@
+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);

database/sql/schema_version_31.sql

@@ -0,0 +1 @@
+alter table feeds add column ignore_http_cache bool default false;

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,8 +22,8 @@ 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.

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/handler.go

@@ -1,8 +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 fever
+package fever // import "miniflux.app/fever"
 
 import (
 	"net/http"
@@ -10,152 +10,51 @@ import (
 	"strings"
 	"time"
 
-	"github.com/miniflux/miniflux/config"
-	"github.com/miniflux/miniflux/http/context"
-	"github.com/miniflux/miniflux/http/request"
-	"github.com/miniflux/miniflux/http/response/json"
-	"github.com/miniflux/miniflux/integration"
-	"github.com/miniflux/miniflux/logger"
-	"github.com/miniflux/miniflux/model"
-	"github.com/miniflux/miniflux/storage"
+	"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"
 )
 
-type baseResponse struct {
-	Version       int   `json:"api_version"`
-	Authenticated int   `json:"auth"`
-	LastRefresh   int64 `json:"last_refreshed_on_time"`
+// 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")
 }
 
-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 {
-	cfg   *config.Config
+type handler struct {
 	store *storage.Storage
 }
 
-// Handler handles Fever API calls
-func (c *Controller) Handler(w http.ResponseWriter, r *http.Request) {
+func (h *handler) serve(w http.ResponseWriter, r *http.Request) {
 	switch {
 	case request.HasQueryParam(r, "groups"):
-		c.handleGroups(w, r)
+		h.handleGroups(w, r)
 	case request.HasQueryParam(r, "feeds"):
-		c.handleFeeds(w, r)
+		h.handleFeeds(w, r)
 	case request.HasQueryParam(r, "favicons"):
-		c.handleFavicons(w, r)
+		h.handleFavicons(w, r)
 	case request.HasQueryParam(r, "unread_item_ids"):
-		c.handleUnreadItems(w, r)
+		h.handleUnreadItems(w, r)
 	case request.HasQueryParam(r, "saved_item_ids"):
-		c.handleSavedItems(w, r)
+		h.handleSavedItems(w, r)
 	case request.HasQueryParam(r, "items"):
-		c.handleItems(w, r)
+		h.handleItems(w, r)
 	case r.FormValue("mark") == "item":
-		c.handleWriteItems(w, r)
+		h.handleWriteItems(w, r)
 	case r.FormValue("mark") == "feed":
-		c.handleWriteFeeds(w, r)
+		h.handleWriteFeeds(w, r)
 	case r.FormValue("mark") == "group":
-		c.handleWriteGroups(w, r)
+		h.handleWriteGroups(w, r)
 	default:
-		json.OK(w, newBaseResponse())
+		json.OK(w, r, newBaseResponse())
 	}
 }
 
@@ -179,20 +78,19 @@ The “Sparks” super group is not included in this response and is composed of
 is_spark equal to 1.
 
 */
-func (c *Controller) handleGroups(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
+func (h *handler) handleGroups(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
 	logger.Debug("[Fever] Fetching groups for userID=%d", userID)
 
-	categories, err := c.store.Categories(userID)
+	categories, err := h.store.Categories(userID)
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	feeds, err := c.store.Feeds(userID)
+	feeds, err := h.store.Feeds(userID)
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
@@ -201,9 +99,9 @@ func (c *Controller) handleGroups(w http.ResponseWriter, r *http.Request) {
 		result.Groups = append(result.Groups, group{ID: category.ID, Title: category.Title})
 	}
 
-	result.FeedsGroups = c.buildFeedGroups(feeds)
+	result.FeedsGroups = h.buildFeedGroups(feeds)
 	result.SetCommonValues()
-	json.OK(w, result)
+	json.OK(w, r, result)
 }
 
 /*
@@ -230,14 +128,13 @@ 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(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
+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 := c.store.Feeds(userID)
+	feeds, err := h.store.Feeds(userID)
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
@@ -260,9 +157,9 @@ func (c *Controller) handleFeeds(w http.ResponseWriter, r *http.Request) {
 		result.Feeds = append(result.Feeds, subscripion)
 	}
 
-	result.FeedsGroups = c.buildFeedGroups(feeds)
+	result.FeedsGroups = h.buildFeedGroups(feeds)
 	result.SetCommonValues()
-	json.OK(w, result)
+	json.OK(w, r, result)
 }
 
 /*
@@ -284,14 +181,13 @@ A PHP/HTML example:
 
 	echo '<img src="data:'.$favicon['data'].'">';
 */
-func (c *Controller) handleFavicons(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
+func (h *handler) handleFavicons(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
 	logger.Debug("[Fever] Fetching favicons for userID=%d", userID)
 
-	icons, err := c.store.Icons(userID)
+	icons, err := h.store.Icons(userID)
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
@@ -304,7 +200,7 @@ func (c *Controller) handleFavicons(w http.ResponseWriter, r *http.Request) {
 	}
 
 	result.SetCommonValues()
-	json.OK(w, result)
+	json.OK(w, r, result)
 }
 
 /*
@@ -338,14 +234,13 @@ Three optional arguments control determine the items included in the response.
 	(added in API version 2)
 
 */
-func (c *Controller) handleItems(w http.ResponseWriter, r *http.Request) {
+func (h *handler) handleItems(w http.ResponseWriter, r *http.Request) {
 	var result itemsResponse
 
-	ctx := context.New(r)
-	userID := ctx.UserID()
+	userID := request.UserID(r)
 	logger.Debug("[Fever] Fetching items for userID=%d", userID)
 
-	builder := c.store.NewEntryQueryBuilder(userID)
+	builder := h.store.NewEntryQueryBuilder(userID)
 	builder.WithoutStatus(model.EntryStatusRemoved)
 	builder.WithLimit(50)
 	builder.WithOrder("id")
@@ -361,7 +256,7 @@ func (c *Controller) handleItems(w http.ResponseWriter, r *http.Request) {
 		builder.WithOffset(maxID)
 	}
 
-	csvItemIDs := request.QueryParam(r, "with_ids", "")
+	csvItemIDs := request.QueryStringParam(r, "with_ids", "")
 	if csvItemIDs != "" {
 		var itemIDs []int64
 
@@ -376,15 +271,15 @@ func (c *Controller) handleItems(w http.ResponseWriter, r *http.Request) {
 
 	entries, err := builder.GetEntries()
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
-	builder = c.store.NewEntryQueryBuilder(userID)
+	builder = h.store.NewEntryQueryBuilder(userID)
 	builder.WithoutStatus(model.EntryStatusRemoved)
 	result.Total, err = builder.CountEntries()
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
@@ -414,7 +309,7 @@ func (c *Controller) handleItems(w http.ResponseWriter, r *http.Request) {
 	}
 
 	result.SetCommonValues()
-	json.OK(w, result)
+	json.OK(w, r, result)
 }
 
 /*
@@ -424,16 +319,15 @@ 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(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
+func (h *handler) handleUnreadItems(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
 	logger.Debug("[Fever] Fetching unread items for userID=%d", userID)
 
-	builder := c.store.NewEntryQueryBuilder(userID)
+	builder := h.store.NewEntryQueryBuilder(userID)
 	builder.WithStatus(model.EntryStatusUnread)
 	entries, err := builder.GetEntries()
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
@@ -445,7 +339,7 @@ func (c *Controller) handleUnreadItems(w http.ResponseWriter, r *http.Request) {
 	var result unreadResponse
 	result.ItemIDs = strings.Join(itemIDs, ",")
 	result.SetCommonValues()
-	json.OK(w, result)
+	json.OK(w, r, result)
 }
 
 /*
@@ -456,17 +350,16 @@ with the remote Fever installation.
 
 	saved_item_ids (string/comma-separated list of positive integers)
 */
-func (c *Controller) handleSavedItems(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
+func (h *handler) handleSavedItems(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
 	logger.Debug("[Fever] Fetching saved items for userID=%d", userID)
 
-	builder := c.store.NewEntryQueryBuilder(userID)
+	builder := h.store.NewEntryQueryBuilder(userID)
 	builder.WithStarred()
 
 	entryIDs, err := builder.GetEntryIDs()
 	if err != nil {
-		json.ServerError(w, err)
+		json.ServerError(w, r, err)
 		return
 	}
 
@@ -477,7 +370,7 @@ func (c *Controller) handleSavedItems(w http.ResponseWriter, r *http.Request) {
 
 	result := &savedResponse{ItemIDs: strings.Join(itemsIDs, ",")}
 	result.SetCommonValues()
-	json.OK(w, result)
+	json.OK(w, r, result)
 }
 
 /*
@@ -485,9 +378,8 @@ func (c *Controller) handleSavedItems(w http.ResponseWriter, r *http.Request) {
 	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(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
+func (h *handler) handleWriteItems(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
 	logger.Debug("[Fever] Receiving mark=item call for userID=%d", userID)
 
 	entryID := request.FormInt64Value(r, "id")
@@ -495,128 +387,108 @@ func (c *Controller) handleWriteItems(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	builder := c.store.NewEntryQueryBuilder(userID)
+	builder := h.store.NewEntryQueryBuilder(userID)
 	builder.WithEntryID(entryID)
 	builder.WithoutStatus(model.EntryStatusRemoved)
 
 	entry, err := builder.GetEntry()
 	if err != nil {
-		json.ServerError(w, err)
+		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", entryID)
-		c.store.SetEntriesStatus(userID, []int64{entryID}, model.EntryStatusRead)
+		h.store.SetEntriesStatus(userID, []int64{entryID}, model.EntryStatusRead)
 	case "unread":
 		logger.Debug("[Fever] Mark entry #%d as unread", entryID)
-		c.store.SetEntriesStatus(userID, []int64{entryID}, model.EntryStatusUnread)
+		h.store.SetEntriesStatus(userID, []int64{entryID}, model.EntryStatusUnread)
 	case "saved", "unsaved":
 		logger.Debug("[Fever] Mark entry #%d as saved/unsaved", entryID)
-		if err := c.store.ToggleBookmark(userID, entryID); err != nil {
-			json.ServerError(w, err)
+		if err := h.store.ToggleBookmark(userID, entryID); err != nil {
+			json.ServerError(w, r, err)
 			return
 		}
 
-		settings, err := c.store.Integration(userID)
+		settings, err := h.store.Integration(userID)
 		if err != nil {
-			json.ServerError(w, err)
+			json.ServerError(w, r, err)
 			return
 		}
 
 		go func() {
-			integration.SendEntry(c.cfg, entry, settings)
+			integration.SendEntry(entry, settings)
 		}()
 	}
 
-	json.OK(w, newBaseResponse())
+	json.OK(w, r, newBaseResponse())
 }
 
 /*
-	mark=? where ? is replaced with feed or group
+	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 (c *Controller) handleWriteFeeds(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Receiving mark=feed call for userID=%d", userID)
-
+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, userID=%d, feedID=%d, before=%v", userID, feedID, before)
+
 	if feedID <= 0 {
 		return
 	}
 
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithStatus(model.EntryStatusUnread)
-	builder.WithFeedID(feedID)
+	go func() {
+		if err := h.store.MarkFeedAsRead(userID, feedID, before); err != nil {
+			logger.Error("[Fever] MarkFeedAsRead failed: %v", err)
+		}
+	}()
 
-	before := request.FormInt64Value(r, "before")
-	if before > 0 {
-		t := time.Unix(before, 0)
-		builder.BeforeDate(t)
-	}
-
-	entryIDs, err := builder.GetEntryIDs()
-	if err != nil {
-		json.ServerError(w, err)
-		return
-	}
-
-	err = c.store.SetEntriesStatus(userID, entryIDs, model.EntryStatusRead)
-	if err != nil {
-		json.ServerError(w, err)
-		return
-	}
-
-	json.OK(w, newBaseResponse())
+	json.OK(w, r, newBaseResponse())
 }
 
 /*
-	mark=? where ? is replaced with feed or group
+	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 (c *Controller) handleWriteGroups(w http.ResponseWriter, r *http.Request) {
-	ctx := context.New(r)
-	userID := ctx.UserID()
-	logger.Debug("[Fever] Receiving mark=group call for userID=%d", userID)
-
+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, userID=%d, groupID=%d, before=%v", userID, groupID, before)
+
 	if groupID < 0 {
 		return
 	}
 
-	builder := c.store.NewEntryQueryBuilder(userID)
-	builder.WithStatus(model.EntryStatusUnread)
-	builder.WithCategoryID(groupID)
+	go func() {
+		var err error
 
-	before := request.FormInt64Value(r, "before")
-	if before > 0 {
-		t := time.Unix(before, 0)
-		builder.BeforeDate(t)
-	}
+		if groupID == 0 {
+			err = h.store.MarkAllAsRead(userID)
+		} else {
+			err = h.store.MarkCategoryAsRead(userID, groupID, before)
+		}
 
-	entryIDs, err := builder.GetEntryIDs()
-	if err != nil {
-		json.ServerError(w, err)
-		return
-	}
+		if err != nil {
+			logger.Error("[Fever] MarkCategoryAsRead failed: %v", err)
+		}
+	}()
 
-	err = c.store.SetEntriesStatus(userID, entryIDs, model.EntryStatusRead)
-	if err != nil {
-		json.ServerError(w, err)
-		return
-	}
-
-	json.OK(w, newBaseResponse())
+	json.OK(w, r, newBaseResponse())
 }
 
 /*
@@ -626,7 +498,7 @@ A feeds_group object has the following members:
     feed_ids (string/comma-separated list of positive integers)
 
 */
-func (c *Controller) buildFeedGroups(feeds model.Feeds) []feedsGroups {
+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))
@@ -642,8 +514,3 @@ func (c *Controller) buildFeedGroups(feeds model.Feeds) []feedsGroups {
 
 	return result
 }
-
-// NewController returns a new Fever API.
-func NewController(cfg *config.Config, store *storage.Storage) *Controller {
-	return &Controller{cfg, store}
-}

fever/middleware.go

@@ -0,0 +1,58 @@
+// 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) {
+		apiKey := r.FormValue("api_key")
+		if apiKey == "" {
+			logger.Info("[Fever] No API key provided")
+			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] No user found with this API key")
+			json.OK(w, r, newAuthFailureResponse())
+			return
+		}
+
+		logger.Info("[Fever] User #%d is authenticated", user.ID)
+		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

@@ -16,17 +16,15 @@ import (
 	"path/filepath"
 	"strings"
 	"text/template"
-	"time"
 
-	"github.com/tdewolff/minify"
-	"github.com/tdewolff/minify/css"
-	"github.com/tdewolff/minify/js"
+	"github.com/tdewolff/minify/v2"
+	"github.com/tdewolff/minify/v2/css"
+	"github.com/tdewolff/minify/v2/js"
 )
 
 const tpl = `// Code generated by go generate; DO NOT EDIT.
-// {{ .Timestamp }}
 
-package {{ .Package }}
+package {{ .Package }} // import "miniflux.app/{{ .ImportPath }}"
 
 var {{ .Map }} = map[string]string{
 {{ range $constant, $content := .Files }}` + "\t" + `"{{ $constant }}": ` + "`{{ $content }}`" + `,
@@ -37,84 +35,188 @@ var {{ .Map }}Checksums = map[string]string{
 {{ end }}}
 `
 
-var generatedTpl = template.Must(template.New("").Parse(tpl))
+var bundleTpl = template.Must(template.New("").Parse(tpl))
 
-type GeneratedFile struct {
-	Package, Map string
-	Timestamp    time.Time
-	Files        map[string]string
-	Checksums    map[string]string
+type Bundle struct {
+	Package    string
+	Map        string
+	ImportPath string
+	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)
+func (b *Bundle) Write(filename string) {
+	f, err := os.Create(filename)
 	if err != nil {
 		panic(err)
 	}
 	defer f.Close()
 
-	generatedTpl.Execute(f, generatedFile)
+	bundleTpl.Execute(f, b)
+}
+
+func NewBundle(pkg, mapName, importPath string) *Bundle {
+	return &Bundle{
+		Package:    pkg,
+		Map:        mapName,
+		ImportPath: importPath,
+		Files:      make(map[string]string),
+		Checksums:  make(map[string]string),
+	}
+}
+
+func readFile(filename string) []byte {
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}
+
+func checksum(data []byte) string {
+	return fmt.Sprintf("%x", sha256.Sum256(data))
+}
+
+func basename(filename string) string {
+	return path.Base(filename)
+}
+
+func stripExtension(filename string) string {
+	filename = strings.TrimSuffix(filename, path.Ext(filename))
+	return strings.Replace(filename, " ", "_", -1)
+}
+
+func glob(pattern string) []string {
+	// There is no Glob function in path package, so we have to use filepath and replace in case of Windows
+	files, _ := filepath.Glob(pattern)
+	for i := range files {
+		if strings.Contains(files[i], "\\") {
+			files[i] = strings.Replace(files[i], "\\", "/", -1)
+		}
+	}
+	return files
+}
+
+func concat(files []string) string {
+	var b strings.Builder
+	for _, file := range files {
+		b.Write(readFile(file))
+	}
+	return b.String()
+}
+
+func generateJSBundle(bundleFile string, bundleFiles map[string][]string, prefixes, suffixes map[string]string) {
+	bundle := NewBundle("static", "Javascripts", "ui/static")
+	m := minify.New()
+	m.AddFunc("text/javascript", js.Minify)
+
+	for name, srcFiles := range bundleFiles {
+		var b strings.Builder
+
+		if prefix, found := prefixes[name]; found {
+			b.WriteString(prefix)
+		}
+
+		b.WriteString(concat(srcFiles))
+
+		if suffix, found := suffixes[name]; found {
+			b.WriteString(suffix)
+		}
+
+		minifiedData, err := m.String("text/javascript", b.String())
+		if err != nil {
+			panic(err)
+		}
+
+		bundle.Files[name] = minifiedData
+		bundle.Checksums[name] = checksum([]byte(minifiedData))
+	}
+
+	bundle.Write(bundleFile)
+}
+
+func generateCSSBundle(bundleFile string, themes map[string][]string) {
+	bundle := NewBundle("static", "Stylesheets", "ui/static")
+	m := minify.New()
+	m.AddFunc("text/css", css.Minify)
+
+	for theme, srcFiles := range themes {
+		data := concat(srcFiles)
+		minifiedData, err := m.String("text/css", data)
+		if err != nil {
+			panic(err)
+		}
+
+		bundle.Files[theme] = minifiedData
+		bundle.Checksums[theme] = checksum([]byte(minifiedData))
+	}
+
+	bundle.Write(bundleFile)
+}
+
+func generateBinaryBundle(bundleFile string, srcFiles []string) {
+	bundle := NewBundle("static", "Binaries", "ui/static")
+
+	for _, srcFile := range srcFiles {
+		data := readFile(srcFile)
+		filename := basename(srcFile)
+		encodedData := base64.StdEncoding.EncodeToString(data)
+
+		bundle.Files[filename] = string(encodedData)
+		bundle.Checksums[filename] = checksum(data)
+	}
+
+	bundle.Write(bundleFile)
+}
+
+func generateBundle(bundleFile, pkg, mapName string, srcFiles []string) {
+	bundle := NewBundle(pkg, mapName, pkg)
+
+	for _, srcFile := range srcFiles {
+		data := readFile(srcFile)
+		filename := stripExtension(basename(srcFile))
+
+		bundle.Files[filename] = string(data)
+		bundle.Checksums[filename] = checksum(data)
+	}
+
+	bundle.Write(bundleFile)
 }
 
 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")
+	generateJSBundle("ui/static/js.go", map[string][]string{
+		"app": []string{
+			"ui/static/js/dom_helper.js",
+			"ui/static/js/touch_handler.js",
+			"ui/static/js/keyboard_handler.js",
+			"ui/static/js/request_builder.js",
+			"ui/static/js/modal_handler.js",
+			"ui/static/js/app.js",
+			"ui/static/js/bootstrap.js",
+		},
+		"sw": []string{
+			"ui/static/js/sw.js",
+		},
+	}, map[string]string{
+		"app": "(function(){'use strict';",
+		"sw":  "'use strict';",
+	}, map[string]string{
+		"app": "})();",
+	})
+
+	generateCSSBundle("ui/static/css.go", map[string][]string{
+		"light_serif":       []string{"ui/static/css/light.css", "ui/static/css/serif.css", "ui/static/css/common.css"},
+		"light_sans_serif":  []string{"ui/static/css/light.css", "ui/static/css/sans_serif.css", "ui/static/css/common.css"},
+		"dark_serif":        []string{"ui/static/css/dark.css", "ui/static/css/serif.css", "ui/static/css/common.css"},
+		"dark_sans_serif":   []string{"ui/static/css/dark.css", "ui/static/css/sans_serif.css", "ui/static/css/common.css"},
+		"system_serif":      []string{"ui/static/css/system.css", "ui/static/css/serif.css", "ui/static/css/common.css"},
+		"system_sans_serif": []string{"ui/static/css/system.css", "ui/static/css/sans_serif.css", "ui/static/css/common.css"},
+	})
+
+	generateBinaryBundle("ui/static/bin.go", glob("ui/static/bin/*"))
+
+	generateBundle("database/sql.go", "database", "SqlMap", glob("database/sql/*.sql"))
+	generateBundle("template/views.go", "template", "templateViewsMap", glob("template/html/*.html"))
+	generateBundle("template/common.go", "template", "templateCommonMap", glob("template/html/common/*.html"))
+	generateBundle("locale/translations.go", "locale", "translations", glob("locale/translations/*.json"))
 }

go.mod

@@ -0,0 +1,21 @@
+module miniflux.app
+
+// +heroku goVersion go1.11
+
+require (
+	github.com/PuerkitoBio/goquery v1.5.1
+	github.com/coreos/go-oidc v2.2.1+incompatible
+	github.com/golang/protobuf v1.4.0 // indirect
+	github.com/gorilla/mux v1.7.4
+	github.com/lib/pq v1.7.0
+	github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35 // indirect
+	github.com/tdewolff/minify/v2 v2.7.4 // indirect
+	golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5
+	golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0
+	golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d
+	golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f // indirect
+	google.golang.org/appengine v1.6.6 // indirect
+	gopkg.in/square/go-jose.v2 v2.5.0 // indirect
+)
+
+go 1.11

go.sum

@@ -0,0 +1,121 @@
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/PuerkitoBio/goquery v1.5.1 h1:PSPBGne8NIUWw+/7vFBV+kG2J/5MOjbzc7154OaKCSE=
+github.com/PuerkitoBio/goquery v1.5.1/go.mod h1:GsLWisAFVj4WgDibEWF4pvYnkVQBpKBKeU+7zCJoLcc=
+github.com/alexbrainman/sspi v0.0.0-20180613141037-e580b900e9f5 h1:P5U+E4x5OkVEKQDklVPmzs71WM56RTTRqV4OrDC//Y4=
+github.com/alexbrainman/sspi v0.0.0-20180613141037-e580b900e9f5/go.mod h1:976q2ETgjT2snVCf2ZaBnyBbVoPERGjUz+0sofzEfro=
+github.com/andybalholm/cascadia v1.1.0 h1:BuuO6sSfQNFRu1LppgbD25Hr2vLYW25JvxHs5zzsLTo=
+github.com/andybalholm/cascadia v1.1.0/go.mod h1:GsXiBklL0woXo1j/WYWtSYYC4ouU9PqHO0sqidkEA4Y=
+github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927/go.mod h1:h/aW8ynjgkuj+NQRlZcDbAbM1ORAbXjXX77sX7T289U=
+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/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+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.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 h1:oOuy+ugB+P/kBdUnG5QaMXSIyJ1q38wWSojYCb3z5VQ=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+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 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/gorilla/mux v1.7.4 h1:VuZ8uybHlWmqV03+zRzdwKL4tUnIp1MAQtp1mIFE1bc=
+github.com/gorilla/mux v1.7.4/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4=
+github.com/gorilla/sessions v1.2.0/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM=
+github.com/hashicorp/go-uuid v1.0.2 h1:cfejS+Tpcp13yd5nYHWDI6qVCny6wyX2Mt5SGur2IGE=
+github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/jcmturner/aescts/v2 v2.0.0 h1:9YKLH6ey7H4eDBXW8khjYslgyqG2xZikXP0EQFKrle8=
+github.com/jcmturner/aescts/v2 v2.0.0/go.mod h1:AiaICIRyfYg35RUkr8yESTqvSy7csK90qZ5xfvvsoNs=
+github.com/jcmturner/dnsutils/v2 v2.0.0 h1:lltnkeZGL0wILNvrNiVCR6Ro5PGU/SeBvVO/8c/iPbo=
+github.com/jcmturner/dnsutils/v2 v2.0.0/go.mod h1:b0TnjGOvI/n42bZa+hmXL+kFJZsFT7G4t3HTlQ184QM=
+github.com/jcmturner/gofork v1.0.0 h1:J7uCkflzTEhUZ64xqKnkDxq3kzc96ajM1Gli5ktUem8=
+github.com/jcmturner/gofork v1.0.0/go.mod h1:MK8+TM0La+2rjBD4jE12Kj1pCCxK7d2LK/UM3ncEo0o=
+github.com/jcmturner/goidentity/v6 v6.0.1 h1:VKnZd2oEIMorCTsFBnJWbExfNN7yZr3EhJAxwOkZg6o=
+github.com/jcmturner/goidentity/v6 v6.0.1/go.mod h1:X1YW3bgtvwAXju7V3LCIMpY0Gbxyjn/mY9zx4tFonSg=
+github.com/jcmturner/gokrb5/v8 v8.2.0 h1:lzPl/30ZLkTveYsYZPKMcgXc8MbnE6RsTd4F9KgiLtk=
+github.com/jcmturner/gokrb5/v8 v8.2.0/go.mod h1:T1hnNppQsBtxW0tCHMHTkAt8n/sABdzZgZdoFrZaZNM=
+github.com/jcmturner/rpc/v2 v2.0.2 h1:gMB4IwRXYsWw4Bc6o/az2HJgFUA1ffSh90i26ZJ6Xl0=
+github.com/jcmturner/rpc/v2 v2.0.2/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJki3ELg/Hc=
+github.com/lib/pq v1.4.0 h1:TmtCFbH+Aw0AixwyttznSMQDgbR5Yed/Gg6S8Funrhc=
+github.com/lib/pq v1.4.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/lib/pq v1.6.0 h1:I5DPxhYJChW9KYc66se+oKFFQX6VuQrKiprsX6ivRZc=
+github.com/lib/pq v1.6.0/go.mod h1:4vXEAYvW1fRQ2/FhZ78H73A60MHw1geSm145z2mdY1g=
+github.com/lib/pq v1.7.0 h1:h93mCPfUSkaul3Ka/VG8uZdmW1uMHDGxzu0NWHuJmHY=
+github.com/lib/pq v1.7.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/matryer/try v0.0.0-20161228173917-9ac251b645a2/go.mod h1:0KeJpeMD6o+O4hW7qJOT7vyQPKrWmj26uf5wMc/IiIs=
+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/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/tdewolff/minify v1.1.0 h1:nxHQi1ML+g3ZbZHffiZ6eC7vMqNvSRfX3KB5Y5y/kfw=
+github.com/tdewolff/minify v2.3.6+incompatible h1:2hw5/9ZvxhWLvBUnHE06gElGYz+Jv9R4Eys0XUzItYo=
+github.com/tdewolff/minify/v2 v2.7.4 h1:r0OZQ3QzWeDS5cXq53Bk4IFIBDZ7fiXIkw1a4bHONsw=
+github.com/tdewolff/minify/v2 v2.7.4/go.mod h1:BkDSm8aMMT0ALGmpt7j3Ra7nLUgZL0qhyrAHXwxcy5w=
+github.com/tdewolff/parse/v2 v2.4.2 h1:Bu2Qv6wepkc+Ou7iB/qHjAhEImlAP5vedzlQRUdj3BI=
+github.com/tdewolff/parse/v2 v2.4.2/go.mod h1:WzaJpRSbwq++EIQHYIRTpbYKNA3gn9it1Ik++q4zyho=
+github.com/tdewolff/test v1.0.6/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20200117160349-530e935923ad/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200311171314-f7b00557c8c4/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5 h1:Q7tZBpemrlsc2I7IyODzhtallWRSm4Q0d09pL6XbQtU=
+golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/net v0.0.0-20180218175443-cbe0f9307d01/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/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-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+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-20200425230154-ff2c4b7c35a0 h1:Jcxah/M+oLZ/R4/z5RzfPzGbPXnVDPkEDtf2JnuxN+U=
+golang.org/x/net v0.0.0-20200425230154-ff2c4b7c35a0/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4 h1:YUO/7uOKsKeq9UokNS62b8FYywz3ker1l1vDZRCRefw=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20181031143558-9b800f95dbbc/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-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd h1:xhmwyvizuTgC2qz7ZlMluP20uW+C3Rm0FD/WLDX8884=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f h1:gWF768j/LaZugp8dyS4UwsslYCYz9XgFxvlgsn0n9H8=
+golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/appengine v1.4.0 h1:/wp5JvzpHIxhs/dumFmF7BXTf3Z+dd4uXta4kVyO508=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+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/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 h1:qdOKuR/EIArgaWNjetjgTzgVTAZ+S/WXVrq9HW9zimw=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/jcmturner/aescts.v1 v1.0.1/go.mod h1:nsR8qBOg+OucoIW+WMhB3GspUQXq9XorLnQb9XtvcOo=
+gopkg.in/jcmturner/dnsutils.v1 v1.0.1/go.mod h1:m3v+5svpVOhtFAP/wSz+yzh4Mc0Fg7eRhxkJMWSIz9Q=
+gopkg.in/jcmturner/goidentity.v3 v3.0.0/go.mod h1:oG2kH0IvSYNIu80dVAyu/yoefjq1mNfM5bm88whjWx4=
+gopkg.in/jcmturner/gokrb5.v7 v7.5.0/go.mod h1:l8VISx+WGYp+Fp7KRbsiUuXTTOnxIc3Tuvyavf11/WM=
+gopkg.in/jcmturner/rpc.v1 v1.1.0/go.mod h1:YIdkC4XfD6GXbzje11McwsDuOlZQSb9W4vfLvuNnlv8=
+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.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

http/client/client.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 client
+package client // import "miniflux.app/http/client"
 
 import (
 	"bytes"
@@ -18,21 +18,18 @@ import (
 	"strings"
 	"time"
 
-	"github.com/miniflux/miniflux/errors"
-	"github.com/miniflux/miniflux/logger"
-	"github.com/miniflux/miniflux/timer"
-	"github.com/miniflux/miniflux/version"
-)
-
-const (
-	// 20 seconds max.
-	requestTimeout = 20
-
-	// 15MB max.
-	maxBodySize = 1024 * 1024 * 15
+	"miniflux.app/config"
+	"miniflux.app/errors"
+	"miniflux.app/logger"
+	"miniflux.app/timer"
+	url_helper "miniflux.app/url"
+	"miniflux.app/version"
 )
 
 var (
+	// DefaultUserAgent sets the User-Agent header used for any requests by miniflux.
+	DefaultUserAgent = "Mozilla/5.0 (compatible; Miniflux/" + version.Version + "; +https://miniflux.app)"
+
 	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)"
@@ -41,15 +38,39 @@ var (
 
 // Client is a HTTP Client :)
 type Client struct {
-	url                 string
+	inputURL            string
+	requestURL          string
 	etagHeader          string
 	lastModifiedHeader  string
 	authorizationHeader string
 	username            string
 	password            string
+	userAgent           string
 	Insecure            bool
 }
 
+func (c *Client) String() string {
+	etagHeader := c.etagHeader
+	if c.etagHeader == "" {
+		etagHeader = "None"
+	}
+
+	lastModifiedHeader := c.lastModifiedHeader
+	if c.lastModifiedHeader == "" {
+		lastModifiedHeader = "None"
+	}
+
+	return fmt.Sprintf(
+		`InputURL=%q RequestURL=%q ETag=%s LastModified=%s BasicAuth=%v UserAgent=%q`,
+		c.inputURL,
+		c.requestURL,
+		etagHeader,
+		lastModifiedHeader,
+		c.authorizationHeader != "" || (c.username != "" && c.password != ""),
+		c.userAgent,
+	)
+}
+
 // WithCredentials defines the username/password for HTTP Basic authentication.
 func (c *Client) WithCredentials(username, password string) *Client {
 	if username != "" && password != "" {
@@ -72,6 +93,14 @@ func (c *Client) WithCacheHeaders(etagHeader, lastModifiedHeader string) *Client
 	return c
 }
 
+// WithUserAgent defines the User-Agent header to use for outgoing requests.
+func (c *Client) WithUserAgent(userAgent string) *Client {
+	if userAgent != "" {
+		c.userAgent = userAgent
+	}
+	return c
+}
+
 // Get execute a GET HTTP request.
 func (c *Client) Get() (*Response, error) {
 	request, err := c.buildRequest(http.MethodGet, nil)
@@ -110,7 +139,12 @@ func (c *Client) PostJSON(data interface{}) (*Response, error) {
 }
 
 func (c *Client) executeRequest(request *http.Request) (*Response, error) {
-	defer timer.ExecutionTime(time.Now(), fmt.Sprintf("[HttpClient] url=%s", c.url))
+	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)
@@ -132,7 +166,7 @@ func (c *Client) executeRequest(request *http.Request) (*Response, error) {
 			case net.Error:
 				nerr := uerr.Err.(net.Error)
 				if nerr.Timeout() {
-					err = errors.NewLocalizedError(errRequestTimeout, requestTimeout)
+					err = errors.NewLocalizedError(errRequestTimeout, config.Opts.HTTPClientTimeout())
 				} else if nerr.Temporary() {
 					err = errors.NewLocalizedError(errTemporaryNetworkOperation, nerr)
 				}
@@ -142,7 +176,7 @@ func (c *Client) executeRequest(request *http.Request) (*Response, error) {
 		return nil, err
 	}
 
-	if resp.ContentLength > maxBodySize {
+	if resp.ContentLength > config.Opts.HTTPClientMaxBodySize() {
 		return nil, fmt.Errorf("client: response too large (%d bytes)", resp.ContentLength)
 	}
 
@@ -157,21 +191,15 @@ func (c *Client) executeRequest(request *http.Request) (*Response, error) {
 		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:%s] URL=%s, EffectiveURL=%s, Code=%d, Length=%d, Type=%s, ETag=%s, LastMod=%s, Expires=%s, Auth=%v",
+	logger.Debug("[HttpClient:After] Method=%s %s; Response => %s",
 		request.Method,
-		c.url,
-		response.EffectiveURL,
-		response.StatusCode,
-		resp.ContentLength,
-		response.ContentType,
-		response.ETag,
-		response.LastModified,
-		resp.Header.Get("Expires"),
-		c.username != "",
+		c.String(),
+		response,
 	)
 
 	// Ignore caching headers for feeds that do not want any cache.
@@ -185,7 +213,8 @@ func (c *Client) executeRequest(request *http.Request) (*Response, error) {
 }
 
 func (c *Client) buildRequest(method string, body io.Reader) (*http.Request, error) {
-	request, err := http.NewRequest(method, c.url, body)
+	c.requestURL = url_helper.RequestURI(c.inputURL)
+	request, err := http.NewRequest(method, c.requestURL, body)
 	if err != nil {
 		return nil, err
 	}
@@ -200,7 +229,7 @@ func (c *Client) buildRequest(method string, body io.Reader) (*http.Request, err
 }
 
 func (c *Client) buildClient() http.Client {
-	client := http.Client{Timeout: time.Duration(requestTimeout * time.Second)}
+	client := http.Client{Timeout: time.Duration(config.Opts.HTTPClientTimeout()) * time.Second}
 	if c.Insecure {
 		client.Transport = &http.Transport{
 			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
@@ -212,7 +241,7 @@ func (c *Client) buildClient() http.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("User-Agent", c.userAgent)
 	headers.Add("Accept", "*/*")
 
 	if c.etagHeader != "" {
@@ -233,5 +262,5 @@ func (c *Client) buildHeaders() http.Header {
 
 // New returns a new HTTP client.
 func New(url string) *Client {
-	return &Client{url: url, Insecure: false}
+	return &Client{inputURL: url, userAgent: DefaultUserAgent, Insecure: false}
 }

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"