Merge ~ubuntu-docker-images/ubuntu-docker-images/+git/prometheus-alertmanager:update-20.04-use-snap into ~ubuntu-docker-images/ubuntu-docker-images/+git/prometheus-alertmanager:0.21-20.04

[Sergio Durigan Junior]

Now that the prometheus-alertmanager snap has the 20.04 track, we can use it to build the OCI image.

This MP seems very big, but all it's doing is:

- Remove everything (except the "oci/" directory);
- Move everything inside "oci/" to the root dir;
- Update Dockerfile to use the snap (like we did for 21.04);
- Update the data YAML file to reflect the path change.

Tested by rebuilding and re-running the unit tests.

[Sergio Durigan Junior (sergiodj)]

Asking for a review from Lucas because he reviewed the 21.04 related change.

[Bryce Harrington (bryce)]

LGTM, +1

You're right this is a sizeable diff, but I focused on visual review of the Dockerfile, Makefile, README.md, and data/prometheus-alertmanager.yaml. All looked pretty standard and consistent with the others. (I did have one question/comment inline below about curl but no changes to suggest.)

I verified locally the branch's Dockerfile builds without issue for me.

review: Approve

[Sergio Durigan Junior (sergiodj)]

Thanks, Bryce.

diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index 8a626c5..0000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,138 +0,0 @@
----
-version: 2.1
-
-orbs:
-  prometheus: prometheus/prometheus@0.8.0
-  go: circleci/go@0.2.0
-
-jobs:
-  test_frontend:
-    # We need to use a machine executor because the front-end validation runs
-    # containers with mounted volumes which isn't supported with the docker
-    # executor (even with setup_remote_docker).
-    machine: true
-    steps:
-    - checkout
-    - run: sudo service docker restart
-    - run:
-        name: Remove existing Go installation
-        command: sudo rm -rf /usr/local/go
-    # Whenever the Go version is updated here, .promu.yml should also be updated.
-    - go/install:
-        version: "1.14"
-    - run:
-        name: Remove generated code
-        command: make clean
-    - run:
-        name: Generate front-end code
-        command: make all
-        working_directory: ~/project/ui/app
-        environment:
-          JUNIT_DIR: ~/test-results
-    - run:
-        name: Generate assets
-        command: make assets
-    - run:
-        name: Generate API v2 code
-        command: make apiv2
-    - run: git diff --exit-code
-    - store_test_results:
-        path: ~/test-results
-
-  test:
-    docker:
-    # Whenever the Go version is updated here, .promu.yml should also be updated.
-    - image: circleci/golang:1.14
-    # maildev containers are for running the email tests against a "real" SMTP server.
-    # See notify/email_test.go for details.
-    - image: djfarrelly/maildev@sha256:624e0ec781e11c3531da83d9448f5861f258ee008c1b2da63b3248bfd680acfa
-      name: maildev-noauth
-      entrypoint: bin/maildev
-      command:
-      - -v
-    - image: djfarrelly/maildev@sha256:624e0ec781e11c3531da83d9448f5861f258ee008c1b2da63b3248bfd680acfa
-      name: maildev-auth
-      entrypoint: bin/maildev
-      command:
-      - -v
-      - --incoming-user
-      - user
-      - --incoming-pass
-      - pass
-
-    environment:
-      EMAIL_NO_AUTH_CONFIG: /tmp/smtp_no_auth.yml
-      EMAIL_AUTH_CONFIG: /tmp/smtp_auth.yml
-
-    steps:
-    - prometheus/setup_environment
-    - go/load-cache:
-        key: v1-go-mod
-    - run:
-        command: |
-          cat \<<EOF > $EMAIL_NO_AUTH_CONFIG
-          smarthost: maildev-noauth:1025
-          server: http://maildev-noauth:1080/
-          EOF
-          cat \<<EOF > $EMAIL_AUTH_CONFIG
-          smarthost: maildev-auth:1025
-          server: http://maildev-auth:1080/
-          username: user
-          password: pass
-          EOF
-    - run:
-        command: make
-        environment:
-          # By default Go uses GOMAXPROCS but a Circle CI executor has many
-          # cores (> 30) while the CPU and RAM resources are throttled. If we
-          # don't limit this to the number of allocated cores, the job is
-          # likely to get OOMed and killed.
-          GOOPTS: "-p 2"
-    - prometheus/check_proto:
-        version: "3.11.4"
-    - prometheus/store_artifact:
-        file: alertmanager
-    - prometheus/store_artifact:
-        file: amtool
-    - go/save-cache:
-        key: v1-go-mod
-    - store_test_results:
-        path: test-results
-
-workflows:
-  version: 2
-  alertmanager:
-    jobs:
-    - test_frontend:
-        filters:
-          tags:
-            only: /.*/
-    - test:
-        filters:
-          tags:
-            only: /.*/
-    - prometheus/build:
-        name: build
-        filters:
-          tags:
-            only: /.*/
-    - prometheus/publish_master:
-        context: org-context
-        requires:
-        - test_frontend
-        - test
-        - build
-        filters:
-          branches:
-            only: master
-    - prometheus/publish_release:
-        context: org-context
-        requires:
-        - test_frontend
-        - test
-        - build
-        filters:
-          tags:
-            only: /^v[0-9]+(\.[0-9]+){2}(-.+|[^-.]*)$/
-          branches:
-            ignore: /.*/
diff --git a/.dockerignore b/.dockerignore
deleted file mode 100644
index 6e6480b..0000000
--- a/.dockerignore
+++ /dev/null
@@ -1,8 +0,0 @@
-.build/
-.tarballs/
-
-!.build/linux-amd64/
-!.build/linux-armv7/
-!.build/linux-arm64/
-!.build/linux-ppc64le/
-!.build/linux-s390x/
diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
deleted file mode 100644
index ce79ffa..0000000
--- a/.github/ISSUE_TEMPLATE.md
+++ /dev/null
@@ -1,47 +0,0 @@
-<!--
-
-    Please do *NOT* ask usage questions in Github issues.
-
-    If your issue is not a feature request or bug report use:
-    https://groups.google.com/forum/#!forum/prometheus-users. If
-    you are unsure whether you hit a bug, search and ask in the
-    mailing list first.
-
-    You can find more information at: https://prometheus.io/community/
-
--->
-
-**What did you do?**
-
-**What did you expect to see?**
-
-**What did you see instead? Under which circumstances?**
-
-**Environment**
-
-* System information:
-
-	insert output of `uname -srm` here
-
-* Alertmanager version:
-
-	insert output of `alertmanager --version` here
-
-* Prometheus version:
-
-	insert output of `prometheus --version` here (if relevant to the issue)
-
-* Alertmanager configuration file:
-```
-insert configuration here
-```
-
-* Prometheus configuration file:
-```
-insert configuration here (if relevant to the issue)
-```
-
-* Logs:
-```
-insert Prometheus and Alertmanager logs relevant to the issue here
-```
diff --git a/.github/stale.yml b/.github/stale.yml
deleted file mode 100644
index 66a72af..0000000
--- a/.github/stale.yml
+++ /dev/null
@@ -1,56 +0,0 @@
-# Configuration for probot-stale - https://github.com/probot/stale
-
-# Number of days of inactivity before an Issue or Pull Request becomes stale
-daysUntilStale: 60
-
-# Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
-# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
-daysUntilClose: false
-
-# Only issues or pull requests with all of these labels are check if stale. Defaults to `[]` (disabled)
-onlyLabels: []
-
-# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
-exemptLabels:
-  - keepalive
-
-# Set to true to ignore issues in a project (defaults to false)
-exemptProjects: false
-
-# Set to true to ignore issues in a milestone (defaults to false)
-exemptMilestones: false
-
-# Set to true to ignore issues with an assignee (defaults to false)
-exemptAssignees: false
-
-# Label to use when marking as stale
-staleLabel: stale
-
-# Comment to post when marking as stale. Set to `false` to disable
-markComment: false
-
-# Comment to post when removing the stale label.
-# unmarkComment: >
-#   Your comment here.
-
-# Comment to post when closing a stale Issue or Pull Request.
-# closeComment: >
-#   Your comment here.
-
-# Limit the number of actions per hour, from 1-30. Default is 30
-limitPerRun: 30
-
-# Limit to only `issues` or `pulls`
-only: pulls
-
-# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls':
-# pulls:
-#   daysUntilStale: 30
-#   markComment: >
-#     This pull request has been automatically marked as stale because it has not had
-#     recent activity. It will be closed if no further activity occurs. Thank you
-#     for your contributions.
-
-# issues:
-#   exemptLabels:
-#     - confirmed
diff --git a/.gitignore b/.gitignore
index 205826a..0350652 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1 @@
-/*.snap
-/parts/
-/prime/
-/stage/
+templates/
diff --git a/.golangci.yml b/.golangci.yml
deleted file mode 100644
index 1a05236..0000000
--- a/.golangci.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-run:
-  modules-download-mode: vendor
-  deadline: 5m
-
-issues:
-  exclude-rules:
-  - path: _test.go
-    linters:
-    - errcheck
-
-linters-settings:
-  errcheck:
-    exclude: scripts/errcheck_excludes.txt
diff --git a/.promu.yml b/.promu.yml
deleted file mode 100644
index 1c417c7..0000000
--- a/.promu.yml
+++ /dev/null
@@ -1,48 +0,0 @@
-go:
-    # Whenever the Go version is updated here, .travis.yml and
-    # .circle/config.yml should also be updated.
-    version: 1.14
-repository:
-    path: github.com/prometheus/alertmanager
-build:
-    binaries:
-        - name: alertmanager
-          path: ./cmd/alertmanager
-        - name: amtool
-          path: ./cmd/amtool
-    flags: -mod vendor -a -tags netgo
-    ldflags: |
-        -X github.com/prometheus/common/version.Version={{.Version}}
-        -X github.com/prometheus/common/version.Revision={{.Revision}}
-        -X github.com/prometheus/common/version.Branch={{.Branch}}
-        -X github.com/prometheus/common/version.BuildUser={{user}}@{{host}}
-        -X github.com/prometheus/common/version.BuildDate={{date "20060102-15:04:05"}}
-tarball:
-    files:
-        - examples/ha/alertmanager.yml
-        - LICENSE
-        - NOTICE
-crossbuild:
-    platforms:
-        - linux/amd64
-        - linux/386
-        - darwin/amd64
-        - darwin/386
-        - windows/amd64
-        - windows/386
-        - freebsd/amd64
-        - freebsd/386
-        - openbsd/amd64
-        - openbsd/386
-        - netbsd/amd64
-        - netbsd/386
-        - dragonfly/amd64
-        - linux/arm
-        - linux/arm64
-        - freebsd/arm
-        - netbsd/arm
-        - linux/ppc64
-        - linux/ppc64le
-        - linux/mips64
-        - linux/mips64le
-        - linux/s390x
diff --git a/CHANGELOG.md b/CHANGELOG.md
deleted file mode 100644
index 93dc0af..0000000
--- a/CHANGELOG.md
+++ /dev/null
@@ -1,564 +0,0 @@
-## 0.21.0 / 2020-06-16
-
-This release removes the HipChat integration as it is discontinued by Atlassian on June 30th 2020.
-
-* [CHANGE] [HipChat] Remove HipChat integration as it is end-of-life. #2282
-* [CHANGE] [amtool] Remove default assignment of environment variables. #2161
-* [CHANGE] [PagerDuty] Enforce 512KB event size limit. #2225
-* [ENHANCEMENT] [amtool] Add `cluster` command to show cluster and peer statuses. #2256
-* [ENHANCEMENT] Add redirection from `/` to the routes prefix when it isn't empty. #2235
-* [ENHANCEMENT] [Webhook] Add `max_alerts` option to limit the number of alerts included in the payload. #2274
-* [ENHANCEMENT] Improve logs for API v2, notifications and clustering. #2177 #2188 #2260 #2261 #2273
-* [BUGFIX] Fix child routes not inheriting their parent route's grouping when `group_by: [...]`. #2154
-* [BUGFIX] [UI] Fix the receiver selector in the Alerts page when the receiver name contains regular expression metacharacters such as `+`. #2090
-* [BUGFIX] Fix error message about start and end time validation. #2173
-* [BUGFIX] Fix a potential race condition in dispatcher. #2208
-* [BUGFIX] [API v2] Return an empty array of peers when the clustering is disabled. #2203
-* [BUGFIX] Fix the registration of `alertmanager_dispatcher_aggregation_groups` and `alertmanager_dispatcher_alert_processing_duration_seconds` metrics. #2200
-* [BUGFIX] Always retry notifications with back-off. #2290
-
-## 0.20.0 / 2019-12-11
-
-* [CHANGE] Check that at least one silence matcher matches a non-empty string. #2081
-* [ENHANCEMENT] [pagerduty] Check that PagerDuty keys aren't empty. #2085
-* [ENHANCEMENT] [template] Add the `stringSlice` function. #2101
-* [ENHANCEMENT] Add `alertmanager_dispatcher_aggregation_groups` and `alertmanager_dispatcher_alert_processing_duration_seconds` metrics. #2113
-* [ENHANCEMENT] Log unused receivers. #2114
-* [ENHANCEMENT] Add `alertmanager_receivers` metric. #2114
-* [ENHANCEMENT] Add `alertmanager_integrations` metric. #2117
-* [ENHANCEMENT] [email] Add Message-Id Header to outgoing emails. #2057
-* [BUGFIX] Don't garbage-collect alerts from the store. #2040
-* [BUGFIX] [ui] Disable the grammarly plugin on all textareas. #2061
-* [BUGFIX] [config] Forbid nil regexp matchers. #2083
-* [BUGFIX] [ui] Fix Silences UI when several filters are applied. #2075
-
-Contributors:
-
-* @CharlesJUDITH
-* @NotAFile
-* @Pger-Y
-* @TheMeier
-* @johncming
-* @n33pm
-* @ntk148v
-* @oddlittlebird
-* @perlun
-* @qoops-1
-* @roidelapluie
-* @simonpasquier
-* @stephenreddek
-* @sylr
-* @vrischmann
-
-## 0.19.0 / 2019-09-03
-
-* [CHANGE] Reject invalid external URLs at startup. #1960
-* [CHANGE] Add Fingerprint to template data. #1945
-* [CHANGE] Check Smarthost validity at config loading. #1957
-* [ENHANCEMENT] Improve error messages for email receiver. #1953
-* [ENHANCEMENT] Log error messages from OpsGenie API. #1965
-* [ENHANCEMENT] Add the ability to configure Slack markdown field. #1967
-* [ENHANCEMENT] Log warning when repeat_interval > retention. #1993
-* [ENHANCEMENT] Add `alertmanager_cluster_enabled` metric. #1973
-* [ENHANCEMENT] [ui] Recreate silence with previous comment. #1927
-* [BUGFIX] [ui] Fix /api/v2/alerts/groups endpoint with similar alert groups. #1964
-* [BUGFIX] Allow slashes in receivers. #2011
-* [BUGFIX] [ui] Fix expand/collapse button with identical alert groups. #2012
-
-## 0.18.0 / 2019-07-08
-
-* [CHANGE] Remove quantile labels from Summary metrics. #1921
-* [CHANGE] [OpsGenie] Move from the deprecated `teams` field in the configuration to `responders`. #1863
-* [CHANGE] [ui] Collapse alert groups on the initial view. #1876
-* [CHANGE] [Wechat] Set the default API secret to blank. #1888
-* [CHANGE/BUGFIX] [PagerDuty] Fix embedding of images, the `text` field in the configuration has been renamed to `href`. #1931
-* [ENHANCEMENT] Use persistent HTTP clients. #1904
-* [ENHANCEMENT] Add `alertmanager_cluster_alive_messages_total`, `alertmanager_cluster_peer_info` and `alertmanager_cluster_pings_seconds` metrics. #1941
-* [ENHANCEMENT] [api] Add missing metrics for API v2. #1902
-* [ENHANCEMENT] [Slack] Log error message on retry errors. #1655
-* [ENHANCEMENT] [ui] Allow to create silences from the alerts filter bar. #1911
-* [ENHANCEMENT] [ui] Enable auto resize the textarea fields. #1893
-* [BUGFIX] [amtool] Use scheme, authentication and base path from the URL if present. #1892 #1940
-* [BUGFIX] [amtool] Support filtering alerts by receiver. #1915
-* [BUGFIX] [api] Fix /api/v2/alerts with multiple receivers. #1948
-* [BUGFIX] [PagerDuty] Truncate description to 1024 chars for PagerDuty v1. #1922
-* [BUGFIX] [ui] Add filtering based off of "active" query param. #1879
-
-
-## 0.17.0 / 2019-05-02
-
-This release includes changes to amtool which are not fully backwards
-compatible with the previous amtool version (#1798) related to backup and
-import of silences. If a backup of silences is created using a previous
-version of amtool (v0.16.1 or earlier), it is possible that not all silences
-can be correctly imported using a later version of amtool.
-
-Additionally, the groups endpoint that was dropped from api v1 has been added
-to api v2. The default for viewing alerts in the UI now consumes from this
-endpoint and displays alerts grouped according to the groups defined in the
-running configuration. Custom grouping is still supported.
-
-This release has added two new flags that may need to be tweaked. For people
-running with a lot of concurrent requests, consider increasing the value of
-`--web.get-concurrency`. An increase in 503 errors indicates that the request
-rate is exceeding the number of currently available workers. The other new
-flag, --web.timeout, limits the time a request is allowed to run. The default
-behavior is to not use a timeout.
-
-* [CHANGE] Modify the self-inhibition prevention semantics (#1873)
-* [CHANGE] Make api/v2/status.cluster.{name,peers} properties optional for Alertmanager with disabled clustering (#1728)
-* [FEATURE] Add groups endpoint to v2 api (#1791)
-* [FEATURE] Optional timeout for HTTP requests (#1743)
-* [ENHANCEMENT] Set HTTP headers to prevent asset caching (#1817)
-* [ENHANCEMENT] API returns current silenced/inhibited state of alerts (#1733)
-* [ENHANCEMENT] Configurable concurrency limit for GET requests (#1743)
-* [ENHANCEMENT] Pushover notifier: support HTML, URL title and custom sounds (#1634)
-* [ENHANCEMENT] Support adding custom fields to VictorOps notifications (#1420)
-* [ENHANCEMENT] Migrate amtool CLI to API v2 (#1798)
-* [ENHANCEMENT][ui] Default alert list view grouped by configured alert groups (#1864)
-* [ENHANCEMENT][ui] Remove superfluous inhibited/silenced text, show inhibited status (#1698, #1862)
-* [ENHANCEMENT][ui] Silence preview now shows already-muted alerts (#1776)
-* [ENHANCEMENT][ui] Sort silences from api/v2 similarly to api/v1 (#1786)
-* [BUGFIX] Trim PagerDuty message summary to 1024 chars (#1701)
-* [BUGFIX] Add fix for race causing alerts to be dropped (#1843)
-* [BUGFIX][ui] Correctly construct filter query string for api (#1869)
-* [BUGFIX][ui] Do not display GroupByAll and GroupBy in marshaled config (#1665)
-* [BUGFIX][ui] Respect regex setting when creating silences (#1697)
-
-## 0.16.2 / 2019-04-03
-
-Updating to v0.16.2 is recommended for all users using the Slack, Pagerduty,
-Hipchat, Wechat, VictorOps and Pushover notifier, as connection errors could
-leak secrets embedded in the notifier's URL to stdout.
-
-* [BUGFIX] Redact notifier URL from logs to not leak secrets embedded in the URL (#1822, #1825)
-* [BUGFIX] Allow sending of unauthenticated SMTP requests when `smtp_auth_username` is not supplied (#1739)
-
-## 0.16.1 / 2019-01-31
-
-* [BUGFIX] Do not populate cluster info if clustering is disabled in API v2 (#1726)
-
-## 0.16.0 / 2019-01-17
-
-This release introduces a new API v2, fully generated via the OpenAPI project
-[1]. At the same time with this release the previous API v1 is being
-deprecated. API v1 will be removed with Alertmanager release v0.18.0.
-
-* [CHANGE] Deprecate API v1
-* [CHANGE] Remove `api/v1/alerts/groups` GET endpoint (#1508 & #1525)
-* [CHANGE] Revert Alertmanager working directory changes in Docker image back to `/alertmanager` (#1435)
-* [CHANGE] Using the recommended label syntax for maintainer in Dockerfile (#1533)
-* [CHANGE] Change `alertmanager_notifications_total` to count attempted notifications, not only successful ones (#1578)
-* [CHANGE] Run as nobody inside container (#1586)
-* [CHANGE] Support `w` for weeks when creating silences, remove `y` for year (#1620)
-* [FEATURE] Introduce OpenAPI generated API v2 (#1352)
-* [FEATURE] Lookup parts in strings using regexp.MatchString in templates (#1452)
-* [FEATURE] Support image/thumb url in attachment in Slack notifier (#1506)
-* [FEATURE] Support custom TLS certificates for the email notifier (#1528)
-* [FEATURE] Add support for images and links in the PagerDuty notification config (#1559)
-* [FEATURE] Add support for grouping by all labels (#1588)
-* [FEATURE] [amtool] Add timeout support to amtool commands (#1471)
-* [FEATURE] [amtool] Added `config routes` tools for visualization and testing routes (#1511)
-* [FEATURE] [amtool] Support adding alerts using amtool (#1461)
-* [ENHANCEMENT] Add support for --log.format (#1658)
-* [ENHANCEMENT] Add CORS support to API v2 (#1667)
-* [ENHANCEMENT] Support HTML, URL title and custom sounds for Pushover (#1634)
-* [ENHANCEMENT] Update Alert compact view (#1698)
-* [ENHANCEMENT] Support adding custom fields to VictorOps notifications (#1420)
-* [ENHANCEMENT] Add help link in UI to Alertmanager documentation (#1522)
-* [ENHANCEMENT] Enforce HTTP or HTTPS URLs in Alertmanager config (#1567)
-* [ENHANCEMENT] Make OpsGenie API Key a templated string (#1594)
-* [ENHANCEMENT] Add name, value and SlackConfirmationField to action in Slack notifier (#1557)
-* [ENHANCEMENT] Show more alert information on silence form and silence view pages (#1601)
-* [ENHANCEMENT] Add cluster peers DNS refresh job (#1428)
-* [BUGFIX] Fix unmarshaling of secret URLs in config (#1663)
-* [BUGFIX] Do not write groupbyall and groupby when marshaling config (#1665)
-* [BUGFIX] Make a copy of firing alerts with EndsAt=0 when flushing (#1686)
-* [BUGFIX] Respect regex matchers when recreating silences in UI (#1697)
-* [BUGFIX] Change DefaultGlobalConfig to a function in Alertmanager configuration (#1656)
-* [BUGFIX] Fix email template typo in alert-warning style (#1421)
-* [BUGFIX] Fix silence redirect on silence creation UI page (#1548)
-* [BUGFIX] Add missing `callback_id` parameter in Slack notifier (#1592)
-* [BUGFIX] Throw error if no auth mechanism matches in email notifier (#1608)
-* [BUGFIX] Use quoted-printable transfer encoding for the email notifier (#1609)
-* [BUGFIX] Do not merge expired gossip messages (#1631)
-* [BUGFIX] Fix "PLAIN" auth during notification via smtp-over-tls on port 465 (#1591)
-* [BUGFIX] [amtool] Support for assuming first label is alertname in silence add and query (#1693)
-* [BUGFIX] [amtool] Support assuming first label is alertname in alert query with matchers (#1575)
-* [BUGFIX] [amtool] Fix config path check in amtool (#1538)
-* [BUGFIX] [amtool] Fix rfc3339 example texts (#1526)
-* [BUGFIX] [amtool] Fixed issue with loading path of a default configs (#1529)
-
-[1] https://github.com/prometheus/alertmanager#api
-
-## 0.15.3 / 2018-11-09
-
-* [BUGFIX] Fix alert merging supporting both empty and set EndsAt property for firing alerts send by Prometheus (#1611)
-
-## 0.15.2 / 2018-08-14
-
-* [ENHANCEMENT] [amtool] Add support for stdin to check-config (#1431)
-* [ENHANCEMENT] Log PagerDuty v1 response on BadRequest (#1481)
-* [BUGFIX] Correctly encode query strings in notifiers (#1516)
-* [BUGFIX] Add cache control headers to the API responses to avoid IE caching (#1500)
-* [BUGFIX] Avoid listener blocking on unsubscribe (#1482)
-* [BUGFIX] Fix a bunch of unhandled errors (#1501)
-* [BUGFIX] Update PagerDuty API V2 to send full details on resolve (#1483)
-* [BUGFIX] Validate URLs at config load time (#1468)
-* [BUGFIX] Fix Settle() interval (#1478)
-* [BUGFIX] Fix email to be green if only none firing (#1475)
-* [BUGFIX] Handle errors in notify (#1474)
-* [BUGFIX] Fix templating of hipchat room id (#1463)
-
-## 0.15.1 / 2018-07-10
-
-* [BUGFIX] Fix email template typo in alert-warning style (#1421)
-* [BUGFIX] Fix regression in Pager Duty config (#1455)
-* [BUGFIX] Catch templating errors in Wechat Notify (#1436)
-* [BUGFIX] Fail when no private address can be found for cluster (#1437)
-* [BUGFIX] Make sure we don't miss the first pushPull when joining cluster (#1456)
-* [BUGFIX] Fix concurrent read and write group error in dispatch (#1447)
-
-## 0.15.0 / 2018-06-22
-
-* [CHANGE] [amtool] Update silence add and update flags (#1298)
-* [CHANGE] Replace deprecated InstrumentHandler() (#1302)
-* [CHANGE] Validate Slack field config and only allow the necessary input (#1334)
-* [CHANGE] Remove legacy alert ingest endpoint (#1362)
-* [CHANGE] Move to memberlist as underlying gossip protocol including cluster flag changes from --mesh.xxx to --cluster.xxx (#1232)
-* [CHANGE] Move Alertmanager working directory in Docker image to /etc/alertmanager (#1313)
-* [BUGFIX/CHANGE] The default group by is no labels. (#1287)
-* [FEATURE] [amtool] Filter alerts by receiver (#1402)
-* [FEATURE] Wait for mesh to settle before sending alerts (#1209)
-* [FEATURE] [amtool] Support basic auth in alertmanager url (#1279)
-* [FEATURE] Make HTTP clients used for integrations configurable
-* [ENHANCEMENT] Support receiving alerts with end time and zero start time
-* [ENHANCEMENT] Sort dispatched alerts by job+instance (#1234)
-* [ENHANCEMENT] Support alert query filters `active` and `unprocessed` (#1366)
-* [ENHANCEMENT] [amtool] Expose alert query flags --active and --unprocessed (#1370)
-* [ENHANCEMENT] Add Slack actions to notifications (#1355)
-* [BUGFIX] Register nflog snapShotSize metric
-* [BUGFIX] Sort alerts in correct order before flushing to notifiers (#1349)
-* [BUGFIX] Don't reset initial wait timer if flush is in-progress (#1301)
-* [BUGFIX] Fix resolved alerts still inhibiting (#1331)
-* [BUGFIX] Template wechat config fields (#1356)
-* [BUGFIX] Notify resolved alerts properly (#1408)
-* [BUGFIX] Fix parsing for label values with commas (#1395)
-* [BUGFIX] Hide sensitive Wechat configuration (#1253)
-* [BUGFIX] Prepopulate matchers when recreating a silence (#1270)
-* [BUGFIX] Fix wechat panic (#1293)
-* [BUGFIX] Allow empty matchers in silences/filtering (#1289)
-* [BUGFIX] Properly configure HTTP client for Wechat integration
-
-## 0.14.0 / 2018-02-12
-
-* [ENHANCEMENT] [amtool] Silence update support dwy suffixes to expire flag (#1197)
-* [ENHANCEMENT] Allow templating PagerDuty receiver severity (#1214)
-* [ENHANCEMENT] Include receiver name in failed notifications log messages (#1207)
-* [ENHANCEMENT] Allow global opsgenie api key (#1208)
-* [ENHANCEMENT] Add mesh metrics (#1225)
-* [ENHANCEMENT] Add Class field to PagerDuty; add templating to PagerDuty-CEF fields (#1231)
-* [BUGFIX] Don't notify of resolved alerts if none were reported firing (#1198)
-* [BUGFIX] Notify only when new firing alerts are added (#1205)
-* [BUGFIX] [mesh] Fix pending connections never set to established (#1204)
-* [BUGFIX] Allow OpsGenie notifier to have empty team fields (#1224)
-* [BUGFIX] Don't count alerts with EndTime in the future as resolved (#1233)
-* [BUGFIX] Speed up re-rendering of Silence UI (#1235)
-* [BUGFIX] Forbid 0 value for group_interval and repeat_interval (#1230)
-* [BUGFIX] Fix WeChat agentid issue (#1229)
-
-## 0.13.0 / 2018-01-12
-
-* [CHANGE] Switch cmd/alertmanager to kingpin (#974)
-* [CHANGE] [amtool] Switch amtool to kingpin (#976)
-* [CHANGE] [amtool] silence query: --expired flag only shows expired silences (#1190)
-* [CHANGE] Return config reload result from reload endpoint (#1180)
-* [FEATURE] UI silence form is populated from location bar (#1148)
-* [FEATURE] Add /-/healthy endpoint (#1159)
-* [ENHANCEMENT] Instrument and log snapshot sizes on maintenance (#1155)
-* [ENHANCEMENT] Make alertGC interval configurable (#1151)
-* [ENHANCEMENT] Display mesh connections in the Status page (#1164)
-* [BUGFIX] Template service keys for pagerduty notifier (#1182)
-* [BUGFIX] Fix expire buttons on the silences page (#1171)
-* [BUGFIX] Fix JavaScript error in MSIE due to endswith() usage (#1172)
-* [BUGFIX] Correctly format UI error output (#1167)
-
-## 0.12.0 / 2017-12-15
-
-* [FEATURE] package amtool in docker container (#1127)
-* [FEATURE] Add notify support for Chinese User wechat (#1059)
-* [FEATURE] [amtool] Add a new `silence import` command (#1082)
-* [FEATURE] [amtool] Add new command to update silence (#1123)
-* [FEATURE] [amtool] Add ability to query for silences that will expire soon (#1120)
-* [ENHANCEMENT] Template source field in PagerDuty alert payload (#1117)
-* [ENHANCEMENT] Add footer field for slack messages (#1141)
-* [ENHANCEMENT] Add Slack additional "fields" to notifications (#1135)
-* [ENHANCEMENT] Adding check for webhook's URL formatting (#1129)
-* [ENHANCEMENT] Let the browser remember the creator of a silence (#1112)
-* [BUGFIX] Fix race in stopping inhibitor (#1118)
-* [BUGFIX] Fix browser UI when entering negative duration (#1132)
-
-## 0.11.0 / 2017-11-16
-
-* [CHANGE] Make silence negative filtering consistent with alert filtering (#1095)
-* [CHANGE] Change HipChat and OpsGenie api config names (#1087)
-* [ENHANCEMENT] amtool: Allow 'd', 'w', 'y' time suffixes when creating silence (#1091)
-* [ENHANCEMENT] Support OpsGenie Priority field (#1094)
-* [BUGFIX] Fix UI when no silences are present (#1090)
-* [BUGFIX] Fix OpsGenie Teams field (#1101)
-* [BUGFIX] Fix OpsGenie Tags field (#1108)
-
-## 0.10.0 / 2017-11-09
-
-* [CHANGE] Prevent inhibiting alerts in the source of the inhibition (#1017)
-* [ENHANCEMENT] Improve amtool check-config use and description text (#1016)
-* [ENHANCEMENT] Add metrics about current silences and alerts (#998)
-* [ENHANCEMENT] Sorted silences based on current status (#1015)
-* [ENHANCEMENT] Add metric of alertmanager position in mesh (#1024)
-* [ENHANCEMENT] Initialise notifications_total and notifications_failed_total (#1011)
-* [ENHANCEMENT] Allow selectable matchers on silence view (#1030)
-* [ENHANCEMENT] Allow template in victorops message_type field (#1038)
-* [ENHANCEMENT] Optionally hide inhibited alerts in API response (#1039)
-* [ENHANCEMENT] Toggle silenced and inhibited alerts in UI (#1049)
-* [ENHANCEMENT] Fix pushover limits (title, message, url) (#1055)
-* [ENHANCEMENT] Add limit to OpsGenie message (#1045)
-* [ENHANCEMENT] Upgrade OpsGenie notifier to v2 API. (#1061)
-* [ENHANCEMENT] Allow template in victorops routing_key field (#1083)
-* [ENHANCEMENT] Add support for PagerDuty API v2 (#1054)
-* [BUGFIX] Fix inhibit race (#1032)
-* [BUGFIX] Fix segfault on amtool (#1031)
-* [BUGFIX] Remove .WasInhibited and .WasSilenced fields of Alert type (#1026)
-* [BUGFIX] nflog: Fix Log() crash when gossip is nil (#1064)
-* [BUGFIX] Fix notifications for flapping alerts (#1071)
-* [BUGFIX] Fix shutdown crash with nil mesh router (#1077)
-* [BUGFIX] Fix negative matchers filtering (#1077)
-
-## 0.9.1 / 2017-09-29
-* [BUGFIX] Fix -web.external-url regression in ui (#1008)
-* [BUGFIX] Fix multipart email implementation (#1009)
-
-## 0.9.0 / 2017-09-28
-* [ENHANCEMENT] Add current time to webhook message (#909)
-* [ENHANCEMENT] Add link_names to slack notifier (#912)
-* [ENHANCEMENT] Make ui labels selectable/highlightable (#932)
-* [ENHANCEMENT] Make links in ui annotations selectable (#946)
-* [ENHANCEMENT] Expose the alert's "fingerprint" (unique identifier) through API (#786)
-* [ENHANCEMENT] Add README information for amtool (#939)
-* [ENHANCEMENT] Use user-set logging option consistently throughout alertmanager (#968)
-* [ENHANCEMENT] Sort alerts returned from API by their fingerprint (#969)
-* [ENHANCEMENT] Add edit/delete silence buttons on silence page view (#970)
-* [ENHANCEMENT] Add check-config subcommand to amtool (#978)
-* [ENHANCEMENT] Add email notification text content support (#934)
-* [ENHANCEMENT] Support passing binary name to make build target (#990)
-* [ENHANCEMENT] Show total no. of silenced alerts in preview (#994)
-* [ENHANCEMENT] Added confirmation dialog when expiring silences (#993)
-* [BUGFIX] Fix crash when no mesh router is configured (#919)
-* [BUGFIX] Render status page without mesh (#920)
-* [BUGFIX] Exit amtool subcommands with non-zero error code (#938)
-* [BUGFIX] Change mktemp invocation in makefile to work for macOS (#971)
-* [BUGFIX] Add a mutex to silences.go:gossipData (#984)
-* [BUGFIX] silences: avoid deadlock (#995)
-* [BUGFIX] Ignore expired silences OnGossip (#999)
-
-## 0.8.0 / 2017-07-20
-
-* [FEATURE] Add ability to filter alerts by receiver in the UI (#890)
-* [FEATURE] Add User-Agent for webhook requests (#893)
-* [ENHANCEMENT] Add possibility to have a global victorops api_key (#897)
-* [ENHANCEMENT] Add EntityDisplayName and improve StateMessage for Victorops
-  (#769)
-* [ENHANCEMENT] Omit empty config fields and show regex upon re-marshaling to
-  elide secrets (#864)
-* [ENHANCEMENT] Parse API error messages in UI (#866)
-* [ENHANCEMENT] Enable sending mail via smtp port 465 (#704)
-* [BUGFIX] Prevent duplicate notifications by sorting matchers (#882)
-* [BUGFIX] Remove timeout for UI requests (#890)
-* [BUGFIX] Update config file location of CLI in flag usage text (#895)
-
-## 0.7.1 / 2017-06-09
-
-* [BUGFIX] Fix filtering by label on Alert list and Silence list page
-
-## 0.7.0 / 2017-06-08
-
-* [CHANGE] Rewrite UI from scratch improving UX
-* [CHANGE] Rename `config` to `configYAML` on `api/v1/status`
-* [FEATURE] Add ability to update a silence on `api/v1/silences` POST endpoint (See #765)
-* [FEATURE] Return alert status on `api/v1/alerts` GET endpoint
-* [FEATURE] Serve silence state on `api/v1/silences` GET endpoint
-* [FEATURE] Add ability to specify a route prefix
-* [FEATURE] Add option to disable AM listening on mesh port
-* [ENHANCEMENT] Add ability to specify `filter` string and `silenced` flag on `api/v1/alerts` GET endpoint
-* [ENHANCEMENT] Update `cache-control` to prevent caching for web assets in general.
-* [ENHANCEMENT] Serve web assets by alertmanager instead of external CDN (See #846)
-* [ENHANCEMENT] Elide secrets in alertmanager config (See #840)
-* [ENHANCEMENT] AMTool: Move config file to a more consistent location (See #843)
-* [BUGFIX] Enable builds for Solaris/Illumos
-* [BUGFIX] Load web assets based on url path (See #323)
-
-## 0.6.2 / 2017-05-09
-
-* [BUGFIX] Correctly link to silences from alert again
-* [BUGFIX] Correctly hide silenced/show active alerts in UI again
-* [BUGFIX] Fix regression of alerts not being displayed until first processing
-* [BUGFIX] Fix internal usage of wrong lock for silence markers
-* [BUGFIX] Adapt amtool's API parsing to recent API changes
-* [BUGFIX] Correctly marshal regexes in config JSON response
-* [CHANGE] Anchor silence regex matchers to be consistent with Prometheus
-* [ENHANCEMENT] Error if root route is using `continue` keyword
-
-## 0.6.1 / 2017-04-28
-
-* [BUGFIX] Fix incorrectly serialized hash for notification providers.
-* [ENHANCEMENT] Add processing status field to alerts.
-* [FEATURE] Add config hash metric.
-
-## 0.6.0 / 2017-04-25
-
-* [BUGFIX] Add `groupKey` to `alerts/groups` endpoint https://github.com/prometheus/alertmanager/pull/576
-* [BUGFIX] Only notify on firing alerts https://github.com/prometheus/alertmanager/pull/595
-* [BUGFIX] Correctly marshal regex's in config for routing tree https://github.com/prometheus/alertmanager/pull/602
-* [BUGFIX] Prevent panic when failing to load config https://github.com/prometheus/alertmanager/pull/607
-* [BUGFIX] Prevent panic when alertmanager is started with an empty `-mesh.peer` https://github.com/prometheus/alertmanager/pull/726
-* [CHANGE] Rename VictorOps config variables https://github.com/prometheus/alertmanager/pull/667
-* [CHANGE] No longer generate releases for openbsd/arm https://github.com/prometheus/alertmanager/pull/732
-* [ENHANCEMENT] Add `DELETE` as accepted CORS method https://github.com/prometheus/alertmanager/commit/0ecc59076ca6b4cbb63252fa7720a3d89d1c81d3
-* [ENHANCEMENT] Switch to using `gogoproto` for protobuf https://github.com/prometheus/alertmanager/pull/715
-* [ENHANCEMENT] Include notifier type in logs and errors https://github.com/prometheus/alertmanager/pull/702
-* [FEATURE] Expose mesh peers on status page https://github.com/prometheus/alertmanager/pull/644
-* [FEATURE] Add `reReplaceAll` template function https://github.com/prometheus/alertmanager/pull/639
-* [FEATURE] Allow label-based filtering alerts/silences through API https://github.com/prometheus/alertmanager/pull/633
-* [FEATURE] Add commandline tool for interacting with alertmanager https://github.com/prometheus/alertmanager/pull/636
-
-## 0.5.1 / 2016-11-24
-
-* [BUGFIX] Fix crash caused by race condition in silencing
-* [ENHANCEMENT] Improve logging of API errors
-* [ENHANCEMENT] Add metrics for the notification log
-
-## 0.5.0 / 2016-11-01
-
-This release requires a storage wipe. It contains fundamental internal
-changes that came with implementing the high availability mode.
-
-* [FEATURE] Alertmanager clustering for high availability
-* [FEATURE] Garbage collection of old silences and notification logs
-* [CHANGE] New storage format
-* [CHANGE] Stricter silence semantics for consistent historical view
-
-## 0.4.2 / 2016-09-02
-
-* [BUGFIX] Fix broken regex checkbox in silence form
-* [BUGFIX] Simplify inconsistent silence update behavior
-
-## 0.4.1 / 2016-08-31
-
-* [BUGFIX] Wait for silence query to finish instead of showing error
-* [BUGFIX] Fix sorting of silences
-* [BUGFIX] Provide visual feedback after creating a silence
-* [BUGFIX] Fix styling of silences
-* [ENHANCEMENT] Provide cleaner API silence interface
-
-## 0.4.0 / 2016-08-23
-
-* [FEATURE] Silences are now paginated in the web ui
-* [CHANGE] Failure to start on unparsed flags
-
-## 0.3.0 / 2016-07-07
-
-* [CHANGE] Alerts are purely in memory and no longer persistent across restarts
-* [FEATURE] Add SMTP LOGIN authentication mechanism
-
-## 0.2.1 / 2016-06-23
-
-* [ENHANCEMENT] Allow inheritance of route receiver
-* [ENHANCEMENT] Add silence cache to silence provider
-* [BUGFIX] Fix HipChat room number in integration URL
-
-## 0.2.0 / 2016-06-17
-
-This release uses a new storage backend based on BoltDB. You have to backup
-and wipe your former storage path to run it.
-
-* [CHANGE] Use BoltDB as data store.
-* [CHANGE] Move SMTP authentication to configuration file
-* [FEATURE] add /-/reload HTTP endpoint
-* [FEATURE] Filter silenced alerts in web UI
-* [ENHANCEMENT] reduce inhibition computation complexity
-* [ENHANCEMENT] Add support for teams and tags in OpsGenie integration
-* [BUGFIX] Handle OpsGenie responses correctly
-* [BUGFIX] Fix Pushover queue length issue
-* [BUGFIX] STARTTLS before querying auth mechanism in email integration
-
-## 0.1.1 / 2016-03-15
-* [BUGFIX] Fix global database lock issue
-* [ENHANCEMENT] Improve SQLite alerts index
-* [ENHANCEMENT] Enable debug endpoint
-
-## 0.1.0 / 2016-02-23
-This version is a full rewrite of the Alertmanager with a very different
-feature set. Thus, there is no meaningful changelog.
-
-Changes with respect to 0.1.0-beta2:
-* [CHANGE] Expose same data structure to templates and webhook
-* [ENHANCEMENT] Show generator URL in default templates and web UI
-* [ENHANCEMENT] Support for Slack icon_emoji field
-* [ENHANCEMENT] Expose incident key to templates and webhook data
-* [ENHANCEMENT] Allow markdown in Slack 'text' field
-* [BUGFIX] Fixed database locking issue
-
-## 0.1.0-beta2 / 2016-02-03
-* [BUGFIX] Properly set timeout for incoming alerts with fixed start time
-* [ENHANCEMENT] Send source field in OpsGenie integration
-* [ENHANCEMENT] Improved routing configuration validation
-* [FEATURE] Basic instrumentation added
-
-## 0.1.0-beta1 / 2016-01-08
-* [BUGFIX] Send full alert group state on each update. Fixes erroneous resolved notifications.
-* [FEATURE] HipChat integration
-* [CHANGE] Slack integration no longer sends resolved notifications by default
-
-## 0.1.0-beta0 / 2015-12-23
-This version is a full rewrite of the Alertmanager with a very different
-feature set. Thus, there is no meaningful changelog.
-
-## 0.0.4 / 2015-09-09
-* [BUGFIX] Fix version info string in startup message.
-* [BUGFIX] Fix Pushover notifications by setting the right priority level, as
-  well as required retry and expiry intervals.
-* [FEATURE] Make it possible to link to individual alerts in the UI.
-* [FEATURE] Rearrange alert columns in UI and allow expanding more alert details.
-* [FEATURE] Add Amazon SNS notifications.
-* [FEATURE] Add OpsGenie Webhook notifications.
-* [FEATURE] Add `-web.external-url` flag to control the externally visible
-  Alertmanager URL.
-* [FEATURE] Add runbook and alertmanager URLs to PagerDuty and email notifications.
-* [FEATURE] Add a GET API to /api/alerts which pulls JSON formatted
-  AlertAggregates.
-* [ENHANCEMENT] Sort alerts consistently in web UI.
-* [ENHANCEMENT] Suggest to use email address as silence creator.
-* [ENHANCEMENT] Make Slack timeout configurable.
-* [ENHANCEMENT] Add channel name to error logging about Slack notifications.
-* [ENHANCEMENT] Refactoring and tests for Flowdock notifications.
-* [ENHANCEMENT] New Dockerfile using alpine-golang-make-onbuild base image.
-* [CLEANUP] Add Docker instructions and other cleanups in README.md.
-* [CLEANUP] Update Makefile.COMMON from prometheus/utils.
-
-## 0.0.3 / 2015-06-10
-* [BUGFIX] Fix email template body writer being called with parameters in wrong order.
-
-## 0.0.2 / 2015-06-09
-
-* [BUGFIX] Fixed silences.json permissions in Docker image.
-* [CHANGE] Changed case of API JSON properties to initial lower letter.
-* [CHANGE] Migrated logging to use http://github.com/prometheus/log.
-* [FEATURE] Flowdock notification support.
-* [FEATURE] Slack notification support.
-* [FEATURE] Generic webhook notification support.
-* [FEATURE] Support for "@"-mentions in HipChat notifications.
-* [FEATURE] Path prefix option to support reverse proxies.
-* [ENHANCEMENT] Improved web redirection and 404 behavior.
-* [CLEANUP] Updated compiled web assets from source.
-* [CLEANUP] Updated fsnotify package to its new source location.
-* [CLEANUP] Updates to README.md and AUTHORS.md.
-* [CLEANUP] Various smaller cleanups and improvements.
diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt
deleted file mode 100644
index af2570c..0000000
--- a/COPYRIGHT.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-Copyright Prometheus Team
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
diff --git a/Dockerfile b/Dockerfile
index 7d98d53..94e2ab5 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,21 +1,40 @@
-ARG ARCH="amd64"
-ARG OS="linux"
-FROM quay.io/prometheus/busybox-${OS}-${ARCH}:latest
-LABEL maintainer="The Prometheus Authors <[e-mail]>"
+FROM ubuntu:focal AS snap-installer
 
-ARG ARCH="amd64"
-ARG OS="linux"
-COPY .build/${OS}-${ARCH}/amtool       /bin/amtool
-COPY .build/${OS}-${ARCH}/alertmanager /bin/alertmanager
-COPY examples/ha/alertmanager.yml      /etc/alertmanager/alertmanager.yml
+RUN set -eux; \
+	apt-get update; \
+	DEBIAN_FRONTEND=noninteractive apt-get full-upgrade -y; \
+	DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+		jq curl ca-certificates squashfs-tools; \
+# taken from https://snapcraft.io/docs/build-on-docker
+# Alternatively, we can install snapd, and issue `snap download prometheus-alertmanager`
+	curl -L $(curl -H 'X-Ubuntu-Series: 16' 'https://api.snapcraft.io/api/v1/snaps/details/prometheus-alertmanager?channel=20.04/edge' | jq '.download_url' -r) --output prometheus-alertmanager.snap; \
+	mkdir -p /snap; \
+	unsquashfs -d /snap/prometheus-alertmanager prometheus-alertmanager.snap
 
-RUN mkdir -p /alertmanager && \
-    chown -R nobody:nogroup etc/alertmanager /alertmanager
+FROM ubuntu:focal
 
-USER       nobody
+ENV TZ UTC
+
+RUN set -eux; \
+	apt-get update; \
+	DEBIAN_FRONTEND=noninteractive apt-get full-upgrade -y; \
+	DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+		tzdata; \
+	rm -rf /var/lib/apt/lists/*; \
+	mkdir -p /alertmanager
+
+COPY --from=snap-installer /snap/prometheus-alertmanager/bin/alertmanager /usr/bin/alertmanager
+COPY --from=snap-installer /snap/prometheus-alertmanager/bin/amtool /usr/bin/amtool
+COPY --from=snap-installer /snap/prometheus-alertmanager/etc/prometheus/alertmanager.yml.example /etc/alertmanager/alertmanager.yml
+
+# Copy the manifest files from the snap
+COPY --from=snap-installer /snap/prometheus-alertmanager/snap/snapcraft.yaml /usr/share/rocks/
+COPY --from=snap-installer /snap/prometheus-alertmanager/snap/manifest.yaml /usr/share/rocks/
+
+# Expose port, configure volume and define the entrypoint
 EXPOSE     9093
 VOLUME     [ "/alertmanager" ]
 WORKDIR    /alertmanager
-ENTRYPOINT [ "/bin/alertmanager" ]
+ENTRYPOINT [ "/usr/bin/alertmanager" ]
 CMD        [ "--config.file=/etc/alertmanager/alertmanager.yml", \
              "--storage.path=/alertmanager" ]
diff --git a/oci/HACKING.md b/HACKING.md
similarity index 100%
rename from oci/HACKING.md
rename to HACKING.md
diff --git a/MAINTAINERS.md b/MAINTAINERS.md
deleted file mode 100644
index e45f5e2..0000000
--- a/MAINTAINERS.md
+++ /dev/null
@@ -1 +0,0 @@
-* Simon Pasquier <[e-mail]>
diff --git a/Makefile b/Makefile
index 3611908..b0bede0 100644
--- a/Makefile
+++ b/Makefile
@@ -1,56 +1,26 @@
-# Copyright 2015 The Prometheus Authors
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Needs to be defined before including Makefile.common to auto-generate targets
-DOCKER_ARCHS ?= amd64 armv7 arm64 ppc64le s390x
-
-include Makefile.common
-
-FRONTEND_DIR             = $(BIN_DIR)/ui/app
-DOCKER_IMAGE_NAME       ?= alertmanager
-
-STATICCHECK_IGNORE =
-
-.PHONY: build-all
-# Will build both the front-end as well as the back-end
-build-all: assets apiv2 build
-
-.PHONY: assets
-assets: asset/assets_vfsdata.go
-
-asset/assets_vfsdata.go: ui/app/script.js ui/app/index.html ui/app/lib template/default.tmpl
-	GO111MODULE=$(GO111MODULE) $(GO) generate $(GOOPTS) ./asset
-	@$(GOFMT) -w ./asset
-
-ui/app/script.js: $(shell find ui/app/src -iname *.elm) api/v2/openapi.yaml
-	cd $(FRONTEND_DIR) && $(MAKE) script.js
-
-.PHONY: apiv2
-apiv2: api/v2/models api/v2/restapi api/v2/client
-
-SWAGGER = docker run \
-	--user=$(shell id -u $(USER)):$(shell id -g $(USER)) \
-	--rm \
-	-v $(shell pwd):/go/src/github.com/prometheus/alertmanager \
-	-w /go/src/github.com/prometheus/alertmanager quay.io/goswagger/swagger:v0.20.1
-
-api/v2/models api/v2/restapi api/v2/client: api/v2/openapi.yaml
-	-rm -r api/v2/{client,models,restapi}
-	$(SWAGGER) generate server -f api/v2/openapi.yaml --copyright-file=COPYRIGHT.txt --exclude-main -A alertmanager --target api/v2/
-	$(SWAGGER) generate client -f api/v2/openapi.yaml --copyright-file=COPYRIGHT.txt --skip-models --target api/v2
-
-.PHONY: clean
-clean:
-	- @rm -rf asset/assets_vfsdata.go \
-                  api/v2/models api/v2/restapi api/v2/client
-	- @cd $(FRONTEND_DIR) && $(MAKE) clean
+RENDERDOWN ?= ../RenderDown/renderdown.py
+PYTHON ?= python3
+
+README_TEMPLATE = templates/README_DOCKERHUB.md
+
+HACKING_TEMPLATE = templates/HACKING_upstream.md
+
+all: all-doc
+
+all-doc: clean-doc readme
+
+get-templates:
+	wget -nv -e "robots=off" -nd -r -np -P templates https://git.launchpad.net/~canonical-server/ubuntu-docker-images/+git/templates/plain/templates/
+
+readme: get-templates
+	mv -v $(README_TEMPLATE) templates/README.md
+	mv -v $(HACKING_TEMPLATE) templates/HACKING.md
+	$(PYTHON) $(RENDERDOWN) templates/README.md > README.md
+	$(PYTHON) $(RENDERDOWN) templates/HACKING.md > HACKING.md
+
+clean: clean-doc
+
+clean-doc:
+	rm -frv templates/ README.md
+
+.PHONY: readme clean clean-doc all all-doc get-templates
diff --git a/Makefile.common b/Makefile.common
deleted file mode 100644
index b1dcf89..0000000
--- a/Makefile.common
+++ /dev/null
@@ -1,296 +0,0 @@
-# Copyright 2018 The Prometheus Authors
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# A common Makefile that includes rules to be reused in different prometheus projects.
-# !!! Open PRs only against the prometheus/prometheus/Makefile.common repository!
-
-# Example usage :
-# Create the main Makefile in the root project directory.
-# include Makefile.common
-# customTarget:
-# 	@echo ">> Running customTarget"
-#
-
-# Ensure GOBIN is not set during build so that promu is installed to the correct path
-unexport GOBIN
-
-GO           ?= go
-GOFMT        ?= $(GO)fmt
-FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH)))
-GOOPTS       ?=
-GOHOSTOS     ?= $(shell $(GO) env GOHOSTOS)
-GOHOSTARCH   ?= $(shell $(GO) env GOHOSTARCH)
-
-GO_VERSION        ?= $(shell $(GO) version)
-GO_VERSION_NUMBER ?= $(word 3, $(GO_VERSION))
-PRE_GO_111        ?= $(shell echo $(GO_VERSION_NUMBER) | grep -E 'go1\.(10|[0-9])\.')
-
-GOVENDOR :=
-GO111MODULE :=
-ifeq (, $(PRE_GO_111))
-	ifneq (,$(wildcard go.mod))
-		# Enforce Go modules support just in case the directory is inside GOPATH (and for Travis CI).
-		GO111MODULE := on
-
-		ifneq (,$(wildcard vendor))
-			# Always use the local vendor/ directory to satisfy the dependencies.
-			GOOPTS := $(GOOPTS) -mod=vendor
-		endif
-	endif
-else
-	ifneq (,$(wildcard go.mod))
-		ifneq (,$(wildcard vendor))
-$(warning This repository requires Go >= 1.11 because of Go modules)
-$(warning Some recipes may not work as expected as the current Go runtime is '$(GO_VERSION_NUMBER)')
-		endif
-	else
-		# This repository isn't using Go modules (yet).
-		GOVENDOR := $(FIRST_GOPATH)/bin/govendor
-	endif
-endif
-PROMU        := $(FIRST_GOPATH)/bin/promu
-pkgs          = ./...
-
-ifeq (arm, $(GOHOSTARCH))
-	GOHOSTARM ?= $(shell GOARM= $(GO) env GOARM)
-	GO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)v$(GOHOSTARM)
-else
-	GO_BUILD_PLATFORM ?= $(GOHOSTOS)-$(GOHOSTARCH)
-endif
-
-GOTEST := $(GO) test
-GOTEST_DIR :=
-ifneq ($(CIRCLE_JOB),)
-ifneq ($(shell which gotestsum),)
-	GOTEST_DIR := test-results
-	GOTEST := gotestsum --junitfile $(GOTEST_DIR)/unit-tests.xml --
-endif
-endif
-
-PROMU_VERSION ?= 0.5.0
-
-GOLANGCI_LINT :=
-GOLANGCI_LINT_OPTS ?=
-GOLANGCI_LINT_VERSION ?= v1.18.0
-# golangci-lint only supports linux, darwin and windows platforms on i386/amd64.
-# windows isn't included here because of the path separator being different.
-ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux darwin))
-	ifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386))
-		GOLANGCI_LINT := $(FIRST_GOPATH)/bin/golangci-lint
-	endif
-endif
-
-PREFIX                  ?= $(shell pwd)
-BIN_DIR                 ?= $(shell pwd)
-DOCKER_IMAGE_TAG        ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD))
-DOCKERFILE_PATH         ?= ./Dockerfile
-DOCKERBUILD_CONTEXT     ?= ./
-DOCKER_REPO             ?= prom
-
-DOCKER_ARCHS            ?= amd64
-
-BUILD_DOCKER_ARCHS = $(addprefix common-docker-,$(DOCKER_ARCHS))
-PUBLISH_DOCKER_ARCHS = $(addprefix common-docker-publish-,$(DOCKER_ARCHS))
-TAG_DOCKER_ARCHS = $(addprefix common-docker-tag-latest-,$(DOCKER_ARCHS))
-
-ifeq ($(GOHOSTARCH),amd64)
-        ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux freebsd darwin windows))
-                # Only supported on amd64
-                test-flags := -race
-        endif
-endif
-
-# This rule is used to forward a target like "build" to "common-build".  This
-# allows a new "build" target to be defined in a Makefile which includes this
-# one and override "common-build" without override warnings.
-%: common-% ;
-
-.PHONY: common-all
-common-all: precheck style check_license lint unused build test
-
-.PHONY: common-style
-common-style:
-	@echo ">> checking code style"
-	@fmtRes=$$($(GOFMT) -d $$(find . -path ./vendor -prune -o -name '*.go' -print)); \
-	if [ -n "$${fmtRes}" ]; then \
-		echo "gofmt checking failed!"; echo "$${fmtRes}"; echo; \
-		echo "Please ensure you are using $$($(GO) version) for formatting code."; \
-		exit 1; \
-	fi
-
-.PHONY: common-check_license
-common-check_license:
-	@echo ">> checking license header"
-	@licRes=$$(for file in $$(find . -type f -iname '*.go' ! -path './vendor/*') ; do \
-               awk 'NR<=3' $$file | grep -Eq "(Copyright|generated|GENERATED)" || echo $$file; \
-       done); \
-       if [ -n "$${licRes}" ]; then \
-               echo "license header checking failed:"; echo "$${licRes}"; \
-               exit 1; \
-       fi
-
-.PHONY: common-deps
-common-deps:
-	@echo ">> getting dependencies"
-ifdef GO111MODULE
-	GO111MODULE=$(GO111MODULE) $(GO) mod download
-else
-	$(GO) get $(GOOPTS) -t ./...
-endif
-
-.PHONY: update-go-deps
-update-go-deps:
-	@echo ">> updating Go dependencies"
-	@for m in $$($(GO) list -mod=readonly -m -f '{{ if and (not .Indirect) (not .Main)}}{{.Path}}{{end}}' all); do \
-		$(GO) get $$m; \
-	done
-	GO111MODULE=$(GO111MODULE) $(GO) mod tidy
-ifneq (,$(wildcard vendor))
-	GO111MODULE=$(GO111MODULE) $(GO) mod vendor
-endif
-
-.PHONY: common-test-short
-common-test-short: $(GOTEST_DIR)
-	@echo ">> running short tests"
-	GO111MODULE=$(GO111MODULE) $(GOTEST) -short $(GOOPTS) $(pkgs)
-
-.PHONY: common-test
-common-test: $(GOTEST_DIR)
-	@echo ">> running all tests"
-	GO111MODULE=$(GO111MODULE) $(GOTEST) $(test-flags) $(GOOPTS) $(pkgs)
-
-$(GOTEST_DIR):
-	@mkdir -p $@
-
-.PHONY: common-format
-common-format:
-	@echo ">> formatting code"
-	GO111MODULE=$(GO111MODULE) $(GO) fmt $(pkgs)
-
-.PHONY: common-vet
-common-vet:
-	@echo ">> vetting code"
-	GO111MODULE=$(GO111MODULE) $(GO) vet $(GOOPTS) $(pkgs)
-
-.PHONY: common-lint
-common-lint: $(GOLANGCI_LINT)
-ifdef GOLANGCI_LINT
-	@echo ">> running golangci-lint"
-ifdef GO111MODULE
-# 'go list' needs to be executed before staticcheck to prepopulate the modules cache.
-# Otherwise staticcheck might fail randomly for some reason not yet explained.
-	GO111MODULE=$(GO111MODULE) $(GO) list -e -compiled -test=true -export=false -deps=true -find=false -tags= -- ./... > /dev/null
-	GO111MODULE=$(GO111MODULE) $(GOLANGCI_LINT) run $(GOLANGCI_LINT_OPTS) $(pkgs)
-else
-	$(GOLANGCI_LINT) run $(pkgs)
-endif
-endif
-
-# For backward-compatibility.
-.PHONY: common-staticcheck
-common-staticcheck: lint
-
-.PHONY: common-unused
-common-unused: $(GOVENDOR)
-ifdef GOVENDOR
-	@echo ">> running check for unused packages"
-	@$(GOVENDOR) list +unused | grep . && exit 1 || echo 'No unused packages'
-else
-ifdef GO111MODULE
-	@echo ">> running check for unused/missing packages in go.mod"
-	GO111MODULE=$(GO111MODULE) $(GO) mod tidy
-ifeq (,$(wildcard vendor))
-	@git diff --exit-code -- go.sum go.mod
-else
-	@echo ">> running check for unused packages in vendor/"
-	GO111MODULE=$(GO111MODULE) $(GO) mod vendor
-	@git diff --exit-code -- go.sum go.mod vendor/
-endif
-endif
-endif
-
-.PHONY: common-build
-common-build: promu
-	@echo ">> building binaries"
-	GO111MODULE=$(GO111MODULE) $(PROMU) build --prefix $(PREFIX) $(PROMU_BINARIES)
-
-.PHONY: common-tarball
-common-tarball: promu
-	@echo ">> building release tarball"
-	$(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR)
-
-.PHONY: common-docker $(BUILD_DOCKER_ARCHS)
-common-docker: $(BUILD_DOCKER_ARCHS)
-$(BUILD_DOCKER_ARCHS): common-docker-%:
-	docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" \
-		-f $(DOCKERFILE_PATH) \
-		--build-arg ARCH="$*" \
-		--build-arg OS="linux" \
-		$(DOCKERBUILD_CONTEXT)
-
-.PHONY: common-docker-publish $(PUBLISH_DOCKER_ARCHS)
-common-docker-publish: $(PUBLISH_DOCKER_ARCHS)
-$(PUBLISH_DOCKER_ARCHS): common-docker-publish-%:
-	docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)"
-
-.PHONY: common-docker-tag-latest $(TAG_DOCKER_ARCHS)
-common-docker-tag-latest: $(TAG_DOCKER_ARCHS)
-$(TAG_DOCKER_ARCHS): common-docker-tag-latest-%:
-	docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:latest"
-
-.PHONY: common-docker-manifest
-common-docker-manifest:
-	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" $(foreach ARCH,$(DOCKER_ARCHS),$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$(ARCH):$(DOCKER_IMAGE_TAG))
-	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)"
-
-.PHONY: promu
-promu: $(PROMU)
-
-$(PROMU):
-	mkdir -p $(FIRST_GOPATH)/bin
-	cp oci/promu/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM)/promu $(FIRST_GOPATH)/bin/promu
-
-.PHONY: proto
-proto:
-	@echo ">> generating code from proto files"
-	@./scripts/genproto.sh
-
-ifdef GOLANGCI_LINT
-$(GOLANGCI_LINT):
-	mkdir -p $(FIRST_GOPATH)/bin
-	curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/$(GOLANGCI_LINT_VERSION)/install.sh \
-		| sed -e '/install -d/d' \
-		| sh -s -- -b $(FIRST_GOPATH)/bin $(GOLANGCI_LINT_VERSION)
-endif
-
-ifdef GOVENDOR
-.PHONY: $(GOVENDOR)
-$(GOVENDOR):
-	GOOS= GOARCH= $(GO) get -u github.com/kardianos/govendor
-endif
-
-.PHONY: precheck
-precheck::
-
-define PRECHECK_COMMAND_template =
-precheck:: $(1)_precheck
-
-PRECHECK_COMMAND_$(1) ?= $(1) $$(strip $$(PRECHECK_OPTIONS_$(1)))
-.PHONY: $(1)_precheck
-$(1)_precheck:
-	@if ! $$(PRECHECK_COMMAND_$(1)) 1>/dev/null 2>&1; then \
-		echo "Execution of '$$(PRECHECK_COMMAND_$(1))' command failed. Is $(1) installed?"; \
-		exit 1; \
-	fi
-endef
diff --git a/NOTICE b/NOTICE
deleted file mode 100644
index f5d0bbb..0000000
--- a/NOTICE
+++ /dev/null
@@ -1,18 +0,0 @@
-Prometheus Alertmanager
-Copyright 2013-2015 The Prometheus Authors
-
-This product includes software developed at
-SoundCloud Ltd. (http://soundcloud.com/).
-
-
-The following components are included in this product:
-
-Bootstrap
-http://getbootstrap.com
-Copyright 2011-2014 Twitter, Inc.
-Licensed under the MIT License
-
-bootstrap-datetimepicker.js
-http://www.eyecon.ro/bootstrap-datepicker
-Copyright 2012 Stefan Petre
-Licensed under the Apache License, Version 2.0
diff --git a/Procfile b/Procfile
deleted file mode 100644
index ab15cfc..0000000
--- a/Procfile
+++ /dev/null
@@ -1,5 +0,0 @@
-a1: ./alertmanager --log.level=debug --storage.path=$TMPDIR/a1 --web.listen-address=:9093  --cluster.listen-address=127.0.0.1:8001 --config.file=examples/ha/alertmanager.yml
-a2: ./alertmanager --log.level=debug --storage.path=$TMPDIR/a2 --web.listen-address=:9094  --cluster.listen-address=127.0.0.1:8002 --cluster.peer=127.0.0.1:8001 --config.file=examples/ha/alertmanager.yml
-a3: ./alertmanager --log.level=debug --storage.path=$TMPDIR/a3 --web.listen-address=:9095  --cluster.listen-address=127.0.0.1:8003 --cluster.peer=127.0.0.1:8001 --config.file=examples/ha/alertmanager.yml
-wh: go run ./examples/webhook/echo.go
-
diff --git a/README.md b/README.md
index c7a3683..6b2c643 100644
--- a/README.md
+++ b/README.md
@@ -1,406 +1,89 @@
-# Alertmanager [![CircleCI](https://circleci.com/gh/prometheus/alertmanager/tree/master.svg?style=shield)][circleci]
+# Prometheus Alertmanager | Ubuntu
 
-[![Docker Repository on Quay](https://quay.io/repository/prometheus/alertmanager/status "Docker Repository on Quay")][quay]
-[![Docker Pulls](https://img.shields.io/docker/pulls/prom/alertmanager.svg?maxAge=604800)][hub]
+Current Prometheus Alertmanager Docker Image from Ubuntu. Receives security updates and rolls to newer Prometheus Alertmanager or Ubuntu LTS. This repository is exempted from per-user rate limits. For [LTS Docker Image](https://ubuntu.com/security/docker-images) versions of this image, see `lts/prometheus-alertmanager`. 
 
-The Alertmanager handles alerts sent by client applications such as the Prometheus server. It takes care of deduplicating, grouping, and routing them to the correct receiver integrations such as email, PagerDuty, or OpsGenie. It also takes care of silencing and inhibition of alerts.
 
-* [Documentation](http://prometheus.io/docs/alerting/alertmanager/)
+## About Prometheus Alertmanager
 
-## Install
+The Alertmanager handles alerts sent by client applications such as the Prometheus server. It takes care of deduplicating, grouping, and routing them to the correct receiver integration such as email, PagerDuty, or OpsGenie. It also takes care of silencing and inhibition of alerts. Read more on the [Prometheus Alertmanager website](https://prometheus.io/docs/alerting/latest/alertmanager/).
 
-There are various ways of installing Alertmanager.
 
-### Precompiled binaries
+## Tags and Architectures
+![LTS](https://assets.ubuntu.com/v1/0a5ff561-LTS%402x.png?h=17)
+Up to 5 years free security maintenance `from lts/prometheus-alertmanager`.
 
-Precompiled binaries for released versions are available in the
-[*download* section](https://prometheus.io/download/)
-on [prometheus.io](https://prometheus.io). Using the latest production release binary
-is the recommended way of installing Alertmanager.
+![ESM](https://assets.ubuntu.com/v1/572f3fbd-ESM%402x.png?h=17)
+Up to 10 years customer security maintenance `from store/canonical/prometheus-alertmanager`.
 
-### Docker images
+_Tags in italics are not available in ubuntu/prometheus-alertmanager but are shown here for completeness._
 
-Docker images are available on [Quay.io](https://quay.io/repository/prometheus/alertmanager).
+| Channel Tag | | | Currently | Architectures |
+|---|---|---|---|---|
+| **`0.21-20.04_beta`** &nbsp;&nbsp; | | | Prometheus Alertmanager 0.21.0 on Ubuntu 20.04 LTS | `amd64`, `arm64`, `ppc64el`, `s390x` |
+| _`track_risk`_ |
 
-### Compiling the binary
+Channel tag shows the most stable channel for that track ordered `stable`, `candidate`, `beta`, `edge`. More risky channels are always implicitly available. So if `beta` is listed, you can also pull `edge`. If `candidate` is listed, you can pull `beta` and `edge`. When `stable` is listed, all four are available. Images are guaranteed to progress through the sequence `edge`, `beta`, `candidate` before `stable`.
 
-You can either `go get` it:
 
-```
-$ GO15VENDOREXPERIMENT=1 go get github.com/prometheus/alertmanager/cmd/...
-# cd $GOPATH/src/github.com/prometheus/alertmanager
-$ alertmanager --config.file=<your_file>
-```
-
-Or clone the repository and build manually:
-
-```
-$ mkdir -p $GOPATH/src/github.com/prometheus
-$ cd $GOPATH/src/github.com/prometheus
-$ git clone https://github.com/prometheus/alertmanager.git
-$ cd alertmanager
-$ make build
-$ ./alertmanager --config.file=<your_file>
-```
-
-You can also build just one of the binaries in this repo by passing a name to the build function:
-```
-$ make build BINARIES=amtool
-```
-
-## Example
-
-This is an example configuration that should cover most relevant aspects of the new YAML configuration format. The full documentation of the configuration can be found [here](https://prometheus.io/docs/alerting/configuration/).
-
-```yaml
-global:
-  # The smarthost and SMTP sender used for mail notifications.
-  smtp_smarthost: 'localhost:25'
-  smtp_from: '[e-mail]'
-
-# The root route on which each incoming alert enters.
-route:
-  # The root route must not have any matchers as it is the entry point for
-  # all alerts. It needs to have a receiver configured so alerts that do not
-  # match any of the sub-routes are sent to someone.
-  receiver: 'team-X-mails'
-
-  # The labels by which incoming alerts are grouped together. For example,
-  # multiple alerts coming in for cluster=A and alertname=LatencyHigh would
-  # be batched into a single group.
-  #
-  # To aggregate by all possible labels use '...' as the sole label name.
-  # This effectively disables aggregation entirely, passing through all
-  # alerts as-is. This is unlikely to be what you want, unless you have
-  # a very low alert volume or your upstream notification system performs
-  # its own grouping. Example: group_by: [...]
-  group_by: ['alertname', 'cluster']
-
-  # When a new group of alerts is created by an incoming alert, wait at
-  # least 'group_wait' to send the initial notification.
-  # This way ensures that you get multiple alerts for the same group that start
-  # firing shortly after another are batched together on the first
-  # notification.
-  group_wait: 30s
-
-  # When the first notification was sent, wait 'group_interval' to send a batch
-  # of new alerts that started firing for that group.
-  group_interval: 5m
-
-  # If an alert has successfully been sent, wait 'repeat_interval' to
-  # resend them.
-  repeat_interval: 3h
-
-  # All the above attributes are inherited by all child routes and can
-  # overwritten on each.
-
-  # The child route trees.
-  routes:
-  # This routes performs a regular expression match on alert labels to
-  # catch alerts that are related to a list of services.
-  - match_re:
-      service: ^(foo1|foo2|baz)$
-    receiver: team-X-mails
-
-    # The service has a sub-route for critical alerts, any alerts
-    # that do not match, i.e. severity != critical, fall-back to the
-    # parent node and are sent to 'team-X-mails'
-    routes:
-    - match:
-        severity: critical
-      receiver: team-X-pager
-
-  - match:
-      service: files
-    receiver: team-Y-mails
-
-    routes:
-    - match:
-        severity: critical
-      receiver: team-Y-pager
-
-  # This route handles all alerts coming from a database service. If there's
-  # no team to handle it, it defaults to the DB team.
-  - match:
-      service: database
-
-    receiver: team-DB-pager
-    # Also group alerts by affected database.
-    group_by: [alertname, cluster, database]
-
-    routes:
-    - match:
-        owner: team-X
-      receiver: team-X-pager
-
-    - match:
-        owner: team-Y
-      receiver: team-Y-pager
-
-
-# Inhibition rules allow to mute a set of alerts given that another alert is
-# firing.
-# We use this to mute any warning-level notifications if the same alert is
-# already critical.
-inhibit_rules:
-- source_match:
-    severity: 'critical'
-  target_match:
-    severity: 'warning'
-  # Apply inhibition if the alertname is the same.
-  # CAUTION: 
-  #   If all label names listed in `equal` are missing 
-  #   from both the source and target alerts,
-  #   the inhibition rule will apply!
-  equal: ['alertname']
-
-
-receivers:
-- name: 'team-X-mails'
-  email_configs:
-  - to: '[e-mail], [e-mail]'
-
-- name: 'team-X-pager'
-  email_configs:
-  - to: '[e-mail]'
-  pagerduty_configs:
-  - routing_key: <team-X-key>
-
-- name: 'team-Y-mails'
-  email_configs:
-  - to: '[e-mail]'
-
-- name: 'team-Y-pager'
-  pagerduty_configs:
-  - routing_key: <team-Y-key>
-
-- name: 'team-DB-pager'
-  pagerduty_configs:
-  - routing_key: <team-DB-key>
-```
-
-## API
-
-The current Alertmanager API is version 2. This API is fully generated via the
-[OpenAPI project](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md)
-and [Go Swagger](https://github.com/go-swagger/go-swagger/) with the exception
-of the HTTP handlers themselves. The API specification can be found in
-[api/v2/openapi.yaml](api/v2/openapi.yaml). A HTML rendered version can be
-accessed [here](http://petstore.swagger.io/?url=https://raw.githubusercontent.com/prometheus/alertmanager/master/api/v2/openapi.yaml).
-Clients can be easily generated via any OpenAPI generator for all major languages.
+## Usage
 
-With the default config, endpoints are accessed under a `/api/v1` or `/api/v2` prefix.
-The v2 `/status` endpoint would be `/api/v2/status`. If `--web.route-prefix` is set then API routes are
-prefixed with that as well, so `--web.route-prefix=/alertmanager/` would
-relate to `/alertmanager/api/v2/status`.
-
-_API v2 is still under heavy development and thereby subject to change._
-
-## amtool
-
-`amtool` is a cli tool for interacting with the Alertmanager API. It is bundled with all releases of Alertmanager.
-
-### Install
-
-Alternatively you can install with:
-```
-go get github.com/prometheus/alertmanager/cmd/amtool
-```
-
-### Examples
-
-View all currently firing alerts:
-```
-$ amtool alert
-Alertname        Starts At                Summary
-Test_Alert       2017-08-02 18:30:18 UTC  This is a testing alert!
-Test_Alert       2017-08-02 18:30:18 UTC  This is a testing alert!
-Check_Foo_Fails  2017-08-02 18:30:18 UTC  This is a testing alert!
-Check_Foo_Fails  2017-08-02 18:30:18 UTC  This is a testing alert!
-```
-
-View all currently firing alerts with extended output:
-```
-$ amtool -o extended alert
-Labels                                        Annotations                                                    Starts At                Ends At                  Generator URL
-alertname="Test_Alert" instance="node0"       link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
-alertname="Test_Alert" instance="node1"       link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
-alertname="Check_Foo_Fails" instance="node0"  link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
-alertname="Check_Foo_Fails" instance="node1"  link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
-```
+Launch this image locally:
 
-In addition to viewing alerts, you can use the rich query syntax provided by Alertmanager:
-```
-$ amtool -o extended alert query alertname="Test_Alert"
-Labels                                   Annotations                                                    Starts At                Ends At                  Generator URL
-alertname="Test_Alert" instance="node0"  link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
-alertname="Test_Alert" instance="node1"  link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
-
-$ amtool -o extended alert query instance=~".+1"
-Labels                                        Annotations                                                    Starts At                Ends At                  Generator URL
-alertname="Test_Alert" instance="node1"       link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
-alertname="Check_Foo_Fails" instance="node1"  link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
-
-$ amtool -o extended alert query alertname=~"Test.*" instance=~".+1"
-Labels                                   Annotations                                                    Starts At                Ends At                  Generator URL
-alertname="Test_Alert" instance="node1"  link="https://example.com" summary="This is a testing alert!"  2017-08-02 18:31:24 UTC  0001-01-01 00:00:00 UTC  http://my.testing.script.local
+```sh
+docker run -d --name prometheus-alertmanager-container -e TZ=UTC -p 30093:9093 ubuntu/prometheus-alertmanager:0.21-20.04_beta
 ```
+Access your Prometheus Alertmanager server at `localhost:30093`.
 
-Silence an alert:
-```
-$ amtool silence add alertname=Test_Alert
-b3ede22e-ca14-4aa0-932c-ca2f3445f926
+#### Parameters
 
-$ amtool silence add alertname="Test_Alert" instance=~".+0"
-e48cb58a-0b17-49ba-b734-3585139b1d25
-```
+| Parameter | Description |
+|---|---|
+| `-e TZ=UTC` | Timezone. |
+| `-p 30093:9093` | Expose Prometheus Alertmanager on `localhost:30093`. |
+| `-v /path/to/alertmanager.yml:/etc/prometheus/alertmanager.yml` | Local [configuration file](https://www.prometheus.io/docs/alerting/latest/configuration/) `alertmanager.yml` (try [this example](https://git.launchpad.net/~canonical-server/ubuntu-docker-images/+git/prometheus-alertmanager/plain/oci/examples/config/alertmanager.yml)). |
+| `-v /path/to/persisted/data:/alertmanager` | Persist data instead of initializing a new database for each newly launched container. **Important note**: the directory you will be using to persist the data needs to belong to `nogroup:nobody`. You can run `chown nogroup:nobody <path_to_persist_data>` before launching your container. |
 
-View silences:
-```
-$ amtool silence query
-ID                                    Matchers              Ends At                  Created By  Comment
-b3ede22e-ca14-4aa0-932c-ca2f3445f926  alertname=Test_Alert  2017-08-02 19:54:50 UTC  kellel
 
-$ amtool silence query instance=~".+0"
-ID                                    Matchers                            Ends At                  Created By  Comment
-e48cb58a-0b17-49ba-b734-3585139b1d25  alertname=Test_Alert instance=~.+0  2017-08-02 22:41:39 UTC  kellel
-```
+#### Testing/Debugging
 
-Expire a silence:
-```
-$ amtool silence expire b3ede22e-ca14-4aa0-932c-ca2f3445f926
-```
+To debug the container:
 
-Expire all silences matching a query:
+```sh
+docker logs -f prometheus-alertmanager-container
 ```
-$ amtool silence query instance=~".+0"
-ID                                    Matchers                            Ends At                  Created By  Comment
-e48cb58a-0b17-49ba-b734-3585139b1d25  alertname=Test_Alert instance=~.+0  2017-08-02 22:41:39 UTC  kellel
-
-$ amtool silence expire $(amtool silence -q query instance=~".+0")
 
-$ amtool silence query instance=~".+0"
+To get an interactive shell:
 
+```sh
+docker exec -it prometheus-alertmanager-container /bin/bash
 ```
 
-Expire all silences:
-```
-$ amtool silence expire $(amtool silence query -q)
-```
 
-### Configuration
+## Deploy with Kubernetes
 
-`amtool` allows a configuration file to specify some options for convenience. The default configuration file paths are `$HOME/.config/amtool/config.yml` or `/etc/amtool/config.yml`
+Works with any Kubernetes; if you don't have one, we recommend you [install MicroK8s](https://microk8s.io/) and `microk8s.enable dns storage` then `snap alias microk8s.kubectl kubectl`.
 
-An example configuration file might look like the following:
+Download
+[alertmanager.yml](https://git.launchpad.net/~canonical-server/ubuntu-docker-images/+git/prometheus-alertmanager/plain/oci/examples/config/alertmanager.yml) and
+[prometheus-alertmanager-deployment.yml](https://git.launchpad.net/~canonical-server/ubuntu-docker-images/+git/prometheus-alertmanager/plain/oci/examples/alertmanager-deployment.yml) and set `containers.prometheus-alertmanager.image` in `prometheus-alertmanager-deployment.yml` to your chosen channel tag (e.g. `ubuntu/prometheus-alertmanager:0.21-20.04_beta`), then:
 
+```sh
+kubectl create configmap prometheus-alertmanager-config --from-file=alertmanager=alertmanager.yml
+kubectl apply -f prometheus-alertmanager-deployment.yml
 ```
-# Define the path that `amtool` can find your `alertmanager` instance
-alertmanager.url: "http://localhost:9093"
-
-# Override the default author. (unset defaults to your username)
-author: [e-mail]
-
-# Force amtool to give you an error if you don't include a comment on a silence
-comment_required: true
 
-# Set a default output format. (unset defaults to simple)
-output: extended
+You will now be able to connect to the Prometheus Alertmanager server on `localhost:30093`.
 
-# Set a default receiver
-receiver: team-X-pager
-```
-
-### Routes
+## Bugs and feature requests
 
-`amtool` allows you to visualize the routes of your configuration in form of text tree view.
-Also you can use it to test the routing by passing it label set of an alert
-and it prints out all receivers the alert would match ordered and separated by `,`.
-(If you use `--verify.receivers` amtool returns error code 1 on mismatch)
+If you find a bug in our image or want to request a specific feature, please file a bug here:
 
-Example of usage:
-```
-# View routing tree of remote Alertmanager
-$ amtool config routes --alertmanager.url=http://localhost:9090
+[https://bugs.launchpad.net/ubuntu-docker-images/+filebug](https://bugs.launchpad.net/ubuntu-docker-images/+filebug)
 
-# Test if alert matches expected receiver
-$ amtool config routes test --config.file=doc/examples/simple.yml --tree --verify.receivers=team-X-pager service=database owner=team-X
-```
+Please title the bug "`prometheus-alertmanager: <issue summary>`". Make sure to include the digest of the image you are using, from:
 
-## High Availability
-
-Alertmanager's high availability is in production use at many companies and is enabled by default.
-
-> Important: Both UDP and TCP are needed in alertmanager 0.15 and higher for the cluster to work.
->  - If you are using a firewall, make sure to whitelist the clustering port for both protocols.
->  - If you are running in a container, make sure to expose the clustering port for both protocols.
-
-To create a highly available cluster of the Alertmanager the instances need to
-be configured to communicate with each other. This is configured using the
-`--cluster.*` flags.
-
-- `--cluster.listen-address` string: cluster listen address (default "0.0.0.0:9094"; empty string disables HA mode)
-- `--cluster.advertise-address` string: cluster advertise address
-- `--cluster.peer` value: initial peers (repeat flag for each additional peer)
-- `--cluster.peer-timeout` value: peer timeout period (default "15s")
-- `--cluster.gossip-interval` value: cluster message propagation speed
-  (default "200ms")
-- `--cluster.pushpull-interval` value: lower values will increase
-  convergence speeds at expense of bandwidth (default "1m0s")
-- `--cluster.settle-timeout` value: maximum time to wait for cluster
-  connections to settle before evaluating notifications.
-- `--cluster.tcp-timeout` value: timeout value for tcp connections, reads and writes (default "10s")
-- `--cluster.probe-timeout` value: time to wait for ack before marking node unhealthy
-  (default "500ms")
-- `--cluster.probe-interval` value: interval between random node probes (default "1s")
-- `--cluster.reconnect-interval` value: interval between attempting to reconnect to lost peers (default "10s")
-- `--cluster.reconnect-timeout` value: length of time to attempt to reconnect to a lost peer (default: "6h0m0s")
-
-The chosen port in the `cluster.listen-address` flag is the port that needs to be
-specified in the `cluster.peer` flag of the other peers.
-
-The `cluster.advertise-address` flag is required if the instance doesn't have
-an IP address that is part of [RFC 6980](https://tools.ietf.org/html/rfc6890)
-with a default route.
-
-To start a cluster of three peers on your local machine use [`goreman`](https://github.com/mattn/goreman) and the
-Procfile within this repository.
-
-	goreman start
-
-To point your Prometheus 1.4, or later, instance to multiple Alertmanagers, configure them
-in your `prometheus.yml` configuration file, for example:
-
-```yaml
-alerting:
-  alertmanagers:
-  - static_configs:
-    - targets:
-      - alertmanager1:9093
-      - alertmanager2:9093
-      - alertmanager3:9093
+```sh
+docker images --no-trunc --quiet ubuntu/prometheus-alertmanager:<tag>
 ```
 
-> Important: Do not load balance traffic between Prometheus and its Alertmanagers, but instead point Prometheus to a list of all Alertmanagers. The Alertmanager implementation expects all alerts to be sent to all Alertmanagers to ensure high availability.
-
-### Turn off high availability
-
-If running Alertmanager in high availability mode is not desired, setting `--cluster.listen-address=` prevents Alertmanager from listening to incoming peer requests.
-
-## Contributing
-
-Check the [Prometheus contributing page](https://github.com/prometheus/prometheus/blob/master/CONTRIBUTING.md).
-
-To contribute to the user interface, refer to [ui/app/CONTRIBUTING.md](ui/app/CONTRIBUTING.md).
-
-## Architecture
-
-![](doc/arch.svg)
-
-## License
-
-Apache License 2.0, see [LICENSE](https://github.com/prometheus/alertmanager/blob/master/LICENSE).
 
-[hub]: https://hub.docker.com/r/prom/alertmanager/
-[circleci]: https://circleci.com/gh/prometheus/alertmanager
-[quay]: https://quay.io/repository/prometheus/alertmanager
diff --git a/VERSION b/VERSION
deleted file mode 100644
index 8854156..0000000
--- a/VERSION
+++ /dev/null
@@ -1 +0,0 @@
-0.21.0
diff --git a/api/api.go b/api/api.go
deleted file mode 100644
index 6b4a883..0000000
--- a/api/api.go
+++ /dev/null
@@ -1,230 +0,0 @@
-// Copyright 2019 Prometheus Team
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package api
-
-import (
-	"errors"
-	"fmt"
-	"net/http"
-	"runtime"
-	"time"
-
-	apiv1 "github.com/prometheus/alertmanager/api/v1"
-	apiv2 "github.com/prometheus/alertmanager/api/v2"
-	"github.com/prometheus/alertmanager/cluster"
-	"github.com/prometheus/alertmanager/config"
-	"github.com/prometheus/alertmanager/dispatch"
-	"github.com/prometheus/alertmanager/provider"
-	"github.com/prometheus/alertmanager/silence"
-	"github.com/prometheus/alertmanager/types"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/common/model"
-	"github.com/prometheus/common/route"
-
-	"github.com/go-kit/kit/log"
-)
-
-// API represents all APIs of Alertmanager.
-type API struct {
-	v1                       *apiv1.API
-	v2                       *apiv2.API
-	requestsInFlight         prometheus.Gauge
-	concurrencyLimitExceeded prometheus.Counter
-	timeout                  time.Duration
-	inFlightSem              chan struct{}
-}
-
-// Options for the creation of an API object. Alerts, Silences, and StatusFunc
-// are mandatory to set. The zero value for everything else is a safe default.
-type Options struct {
-	// Alerts to be used by the API. Mandatory.
-	Alerts provider.Alerts
-	// Silences to be used by the API. Mandatory.
-	Silences *silence.Silences
-	// StatusFunc is used be the API to retrieve the AlertStatus of an
-	// alert. Mandatory.
-	StatusFunc func(model.Fingerprint) types.AlertStatus
-	// Peer from the gossip cluster. If nil, no clustering will be used.
-	Peer *cluster.Peer
-	// Timeout for all HTTP connections. The zero value (and negative
-	// values) result in no timeout.
-	Timeout time.Duration
-	// Concurrency limit for GET requests. The zero value (and negative
-	// values) result in a limit of GOMAXPROCS or 8, whichever is
-	// larger. Status code 503 is served for GET requests that would exceed
-	// the concurrency limit.
-	Concurrency int
-	// Logger is used for logging, if nil, no logging will happen.
-	Logger log.Logger
-	// Registry is used to register Prometheus metrics. If nil, no metrics
-	// registration will happen.
-	Registry prometheus.Registerer
-	// GroupFunc returns a list of alert groups. The alerts are grouped
-	// according to the current active configuration. Alerts returned are
-	// filtered by the arguments provided to the function.
-	GroupFunc func(func(*dispatch.Route) bool, func(*types.Alert, time.Time) bool) (dispatch.AlertGroups, map[model.Fingerprint][]string)
-}
-
-func (o Options) validate() error {
-	if o.Alerts == nil {
-		return errors.New("mandatory field Alerts not set")
-	}
-	if o.Silences == nil {
-		return errors.New("mandatory field Silences not set")
-	}
-	if o.StatusFunc == nil {
-		return errors.New("mandatory field StatusFunc not set")
-	}
-	if o.GroupFunc == nil {
-		return errors.New("mandatory field GroupFunc not set")
-	}
-	return nil
-}
-
-// New creates a new API object combining all API versions. Note that an Update
-// call is also needed to get the APIs into an operational state.
-func New(opts Options) (*API, error) {
-	if err := opts.validate(); err != nil {
-		return nil, fmt.Errorf("invalid API options: %s", err)
-	}
-	l := opts.Logger
-	if l == nil {
-		l = log.NewNopLogger()
-	}
-	concurrency := opts.Concurrency
-	if concurrency < 1 {
-		concurrency = runtime.GOMAXPROCS(0)
-		if concurrency < 8 {
-			concurrency = 8
-		}
-	}
-
-	v1 := apiv1.New(
-		opts.Alerts,
-		opts.Silences,
-		opts.StatusFunc,
-		opts.Peer,
-		log.With(l, "version", "v1"),
-		opts.Registry,
-	)
-
-	v2, err := apiv2.NewAPI(
-		opts.Alerts,
-		opts.GroupFunc,
-		opts.StatusFunc,
-		opts.Silences,
-		opts.Peer,
-		log.With(l, "version", "v2"),
-		opts.Registry,
-	)
-
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO(beorn7): For now, this hardcodes the method="get" label. Other
-	// methods should get the same instrumentation.
-	requestsInFlight := prometheus.NewGauge(prometheus.GaugeOpts{
-		Name:        "alertmanager_http_requests_in_flight",
-		Help:        "Current number of HTTP requests being processed.",
-		ConstLabels: prometheus.Labels{"method": "get"},
-	})
-	concurrencyLimitExceeded := prometheus.NewCounter(prometheus.CounterOpts{
-		Name:        "alertmanager_http_concurrency_limit_exceeded_total",
-		Help:        "Total number of times an HTTP request failed because the concurrency limit was reached.",
-		ConstLabels: prometheus.Labels{"method": "get"},
-	})
-	if opts.Registry != nil {
-		if err := opts.Registry.Register(requestsInFlight); err != nil {
-			return nil, err
-		}
-		if err := opts.Registry.Register(concurrencyLimitExceeded); err != nil {
-			return nil, err
-		}
-	}
-
-	return &API{
-		v1:                       v1,
-		v2:                       v2,
-		requestsInFlight:         requestsInFlight,
-		concurrencyLimitExceeded: concurrencyLimitExceeded,
-		timeout:                  opts.Timeout,
-		inFlightSem:              make(chan struct{}, concurrency),
-	}, nil
-}
-
-// Register all APIs. It registers APIv1 with the provided router directly. As
-// APIv2 works on the http.Handler level, this method also creates a new
-// http.ServeMux and then uses it to register both the provided router (to
-// handle "/") and APIv2 (to handle "<routePrefix>/api/v2"). The method returns
-// the newly created http.ServeMux. If a timeout has been set on construction of
-// API, it is enforced for all HTTP request going through this mux. The same is
-// true for the concurrency limit, with the exception that it is only applied to
-// GET requests.
-func (api *API) Register(r *route.Router, routePrefix string) *http.ServeMux {
-	api.v1.Register(r.WithPrefix("/api/v1"))
-
-	mux := http.NewServeMux()
-	mux.Handle("/", api.limitHandler(r))
-
-	apiPrefix := ""
-	if routePrefix != "/" {
-		apiPrefix = routePrefix
-	}
-	// TODO(beorn7): HTTP instrumentation is only in place for Router. Since
-	// /api/v2 works on the Handler level, it is currently not instrumented
-	// at all (with the exception of requestsInFlight, which is handled in
-	// limitHandler below).
-	mux.Handle(
-		apiPrefix+"/api/v2/",
-		api.limitHandler(http.StripPrefix(apiPrefix+"/api/v2", api.v2.Handler)),
-	)
-
-	return mux
-}
-
-// Update config and resolve timeout of each API. APIv2 also needs
-// setAlertStatus to be updated.
-func (api *API) Update(cfg *config.Config, setAlertStatus func(model.LabelSet)) {
-	api.v1.Update(cfg)
-	api.v2.Update(cfg, setAlertStatus)
-}
-
-func (api *API) limitHandler(h http.Handler) http.Handler {
-	concLimiter := http.HandlerFunc(func(rsp http.ResponseWriter, req *http.Request) {
-		if req.Method == http.MethodGet { // Only limit concurrency of GETs.
-			select {
-			case api.inFlightSem <- struct{}{}: // All good, carry on.
-				api.requestsInFlight.Inc()
-				defer func() {
-					<-api.inFlightSem
-					api.requestsInFlight.Dec()
-				}()
-			default:
-				api.concurrencyLimitExceeded.Inc()
-				http.Error(rsp, fmt.Sprintf(
-					"Limit of concurrent GET requests reached (%d), try again later.\n", cap(api.inFlightSem),
-				), http.StatusServiceUnavailable)
-				return
-			}
-		}
-		h.ServeHTTP(rsp, req)
-	})
-	if api.timeout <= 0 {
-		return concLimiter
-	}
-	return http.TimeoutHandler(concLimiter, api.timeout, fmt.Sprintf(
-		"Exceeded configured timeout of %v.\n", api.timeout,
-	))
-}
diff --git a/api/metrics/metrics.go b/api/metrics/metrics.go
deleted file mode 100644
index 483569a..0000000
--- a/api/metrics/metrics.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2019 Prometheus Team
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package metrics
-
-import "github.com/prometheus/client_golang/prometheus"
-
-// Alerts stores metrics for alerts which are common across all API versions.
-type Alerts struct {
-	firing   prometheus.Counter
-	resolved prometheus.Counter
-	invalid  prometheus.Counter
-}
-
-// NewAlerts returns an *Alerts struct for the given API version.
-func NewAlerts(version string, r prometheus.Registerer) *Alerts {
-	numReceivedAlerts := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Name:        "alertmanager_alerts_received_total",
-		Help:        "The total number of received alerts.",
-		ConstLabels: prometheus.Labels{"version": version},
-	}, []string{"status"})
-	numInvalidAlerts := prometheus.NewCounter(prometheus.CounterOpts{
-		Name:        "alertmanager_alerts_invalid_total",
-		Help:        "The total number of received alerts that were invalid.",
-		ConstLabels: prometheus.Labels{"version": version},
-	})
-	if r != nil {
-		r.MustRegister(numReceivedAlerts, numInvalidAlerts)
-	}
-	return &Alerts{
-		firing:   numReceivedAlerts.WithLabelValues("firing"),
-		resolved: numReceivedAlerts.WithLabelValues("resolved"),
-		invalid:  numInvalidAlerts,
-	}
-}
-
-// Firing returns a counter of firing alerts.
-func (a *Alerts) Firing() prometheus.Counter { return a.firing }
-
-// Resolved returns a counter of resolved alerts.
-func (a *Alerts) Resolved() prometheus.Counter { return a.resolved }
-
-// Invalid returns a counter of invalid alerts.
-func (a *Alerts) Invalid() prometheus.Counter { return a.invalid }
diff --git a/api/v1/api.go b/api/v1/api.go
deleted file mode 100644
index 3a14664..0000000
--- a/api/v1/api.go
+++ /dev/null
@@ -1,797 +0,0 @@
-// Copyright 2015 Prometheus Team
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package v1
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"regexp"
-	"sort"
-	"sync"
-	"time"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/common/model"
-	"github.com/prometheus/common/route"
-	"github.com/prometheus/common/version"
-
-	"github.com/prometheus/alertmanager/api/metrics"
-	"github.com/prometheus/alertmanager/cluster"
-	"github.com/prometheus/alertmanager/config"
-	"github.com/prometheus/alertmanager/dispatch"
-	"github.com/prometheus/alertmanager/pkg/labels"
-	"github.com/prometheus/alertmanager/provider"
-	"github.com/prometheus/alertmanager/silence"
-	"github.com/prometheus/alertmanager/silence/silencepb"
-	"github.com/prometheus/alertmanager/types"
-)
-
-var corsHeaders = map[string]string{
-	"Access-Control-Allow-Headers":  "Accept, Authorization, Content-Type, Origin",
-	"Access-Control-Allow-Methods":  "GET, POST, DELETE, OPTIONS",
-	"Access-Control-Allow-Origin":   "*",
-	"Access-Control-Expose-Headers": "Date",
-	"Cache-Control":                 "no-cache, no-store, must-revalidate",
-}
-
-// Alert is the API representation of an alert, which is a regular alert
-// annotated with silencing and inhibition info.
-type Alert struct {
-	*model.Alert
-	Status      types.AlertStatus `json:"status"`
-	Receivers   []string          `json:"receivers"`
-	Fingerprint string            `json:"fingerprint"`
-}
-
-// Enables cross-site script calls.
-func setCORS(w http.ResponseWriter) {
-	for h, v := range corsHeaders {
-		w.Header().Set(h, v)
-	}
-}
-
-// API provides registration of handlers for API routes.
-type API struct {
-	alerts   provider.Alerts
-	silences *silence.Silences
-	config   *config.Config
-	route    *dispatch.Route
-	uptime   time.Time
-	peer     *cluster.Peer
-	logger   log.Logger
-	m        *metrics.Alerts
-
-	getAlertStatus getAlertStatusFn
-
-	mtx sync.RWMutex
-}
-
-type getAlertStatusFn func(model.Fingerprint) types.AlertStatus
-
-// New returns a new API.
-func New(
-	alerts provider.Alerts,
-	silences *silence.Silences,
-	sf getAlertStatusFn,
-	peer *cluster.Peer,
-	l log.Logger,
-	r prometheus.Registerer,
-) *API {
-	if l == nil {
-		l = log.NewNopLogger()
-	}
-
-	return &API{
-		alerts:         alerts,
-		silences:       silences,
-		getAlertStatus: sf,
-		uptime:         time.Now(),
-		peer:           peer,
-		logger:         l,
-		m:              metrics.NewAlerts("v1", r),
-	}
-}
-
-// Register registers the API handlers under their correct routes
-// in the given router.
-func (api *API) Register(r *route.Router) {
-	wrap := func(f http.HandlerFunc) http.HandlerFunc {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			setCORS(w)
-			f(w, r)
-		})
-	}
-
-	r.Options("/*path", wrap(func(w http.ResponseWriter, r *http.Request) {}))
-
-	r.Get("/status", wrap(api.status))
-	r.Get("/receivers", wrap(api.receivers))
-
-	r.Get("/alerts", wrap(api.listAlerts))
-	r.Post("/alerts", wrap(api.addAlerts))
-
-	r.Get("/silences", wrap(api.listSilences))
-	r.Post("/silences", wrap(api.setSilence))
-	r.Get("/silence/:sid", wrap(api.getSilence))
-	r.Del("/silence/:sid", wrap(api.delSilence))
-}
-
-// Update sets the configuration string to a new value.
-func (api *API) Update(cfg *config.Config) {
-	api.mtx.Lock()
-	defer api.mtx.Unlock()
-
-	api.config = cfg
-	api.route = dispatch.NewRoute(cfg.Route, nil)
-}
-
-type errorType string
-
-const (
-	errorInternal errorType = "server_error"
-	errorBadData  errorType = "bad_data"
-)
-
-type apiError struct {
-	typ errorType
-	err error
-}
-
-func (e *apiError) Error() string {
-	return fmt.Sprintf("%s: %s", e.typ, e.err)
-}
-
-func (api *API) receivers(w http.ResponseWriter, req *http.Request) {
-	api.mtx.RLock()
-	defer api.mtx.RUnlock()
-
-	receivers := make([]string, 0, len(api.config.Receivers))
-	for _, r := range api.config.Receivers {
-		receivers = append(receivers, r.Name)
-	}
-
-	api.respond(w, receivers)
-}
-
-func (api *API) status(w http.ResponseWriter, req *http.Request) {
-	api.mtx.RLock()
-
-	var status = struct {
-		ConfigYAML    string            `json:"configYAML"`
-		ConfigJSON    *config.Config    `json:"configJSON"`
-		VersionInfo   map[string]string `json:"versionInfo"`
-		Uptime        time.Time         `json:"uptime"`
-		ClusterStatus *clusterStatus    `json:"clusterStatus"`
-	}{
-		ConfigYAML: api.config.String(),
-		ConfigJSON: api.config,
-		VersionInfo: map[string]string{
-			"version":   version.Version,
-			"revision":  version.Revision,
-			"branch":    version.Branch,
-			"buildUser": version.BuildUser,
-			"buildDate": version.BuildDate,
-			"goVersion": version.GoVersion,
-		},
-		Uptime:        api.uptime,
-		ClusterStatus: getClusterStatus(api.peer),
-	}
-
-	api.mtx.RUnlock()
-
-	api.respond(w, status)
-}
-
-type peerStatus struct {
-	Name    string `json:"name"`
-	Address string `json:"address"`
-}
-
-type clusterStatus struct {
-	Name   string       `json:"name"`
-	Status string       `json:"status"`
-	Peers  []peerStatus `json:"peers"`
-}
-
-func getClusterStatus(p *cluster.Peer) *clusterStatus {
-	if p == nil {
-		return nil
-	}
-	s := &clusterStatus{Name: p.Name(), Status: p.Status()}
-
-	for _, n := range p.Peers() {
-		s.Peers = append(s.Peers, peerStatus{
-			Name:    n.Name,
-			Address: n.Address(),
-		})
-	}
-	return s
-}
-
-func (api *API) listAlerts(w http.ResponseWriter, r *http.Request) {
-	var (
-		err            error
-		receiverFilter *regexp.Regexp
-		// Initialize result slice to prevent api returning `null` when there
-		// are no alerts present
-		res      = []*Alert{}
-		matchers = []*labels.Matcher{}
-		ctx      = r.Context()
-
-		showActive, showInhibited     bool
-		showSilenced, showUnprocessed bool
-	)
-
-	getBoolParam := func(name string) (bool, error) {
-		v := r.FormValue(name)
-		if v == "" {
-			return true, nil
-		}
-		if v == "false" {
-			return false, nil
-		}
-		if v != "true" {
-			err := fmt.Errorf("parameter %q can either be 'true' or 'false', not %q", name, v)
-			api.respondError(w, apiError{
-				typ: errorBadData,
-				err: err,
-			}, nil)
-			return false, err
-		}
-		return true, nil
-	}
-
-	if filter := r.FormValue("filter"); filter != "" {
-		matchers, err = labels.ParseMatchers(filter)
-		if err != nil {
-			api.respondError(w, apiError{
-				typ: errorBadData,
-				err: err,
-			}, nil)
-			return
-		}
-	}
-
-	showActive, err = getBoolParam("active")
-	if err != nil {
-		return
-	}
-
-	showSilenced, err = getBoolParam("silenced")
-	if err != nil {
-		return
-	}
-
-	showInhibited, err = getBoolParam("inhibited")
-	if err != nil {
-		return
-	}
-
-	showUnprocessed, err = getBoolParam("unprocessed")
-	if err != nil {
-		return
-	}
-
-	if receiverParam := r.FormValue("receiver"); receiverParam != "" {
-		receiverFilter, err = regexp.Compile("^(?:" + receiverParam + ")$")
-		if err != nil {
-			api.respondError(w, apiError{
-				typ: errorBadData,
-				err: fmt.Errorf(
-					"failed to parse receiver param: %s",
-					receiverParam,
-				),
-			}, nil)
-			return
-		}
-	}
-
-	alerts := api.alerts.GetPending()
-	defer alerts.Close()
-
-	api.mtx.RLock()
-	for a := range alerts.Next() {
-		if err = alerts.Err(); err != nil {
-			break
-		}
-		if err = ctx.Err(); err != nil {
-			break
-		}
-
-		routes := api.route.Match(a.Labels)
-		receivers := make([]string, 0, len(routes))
-		for _, r := range routes {
-			receivers = append(receivers, r.RouteOpts.Receiver)
-		}
-
-		if receiverFilter != nil && !receiversMatchFilter(receivers, receiverFilter) {
-			continue
-		}
-
-		if !alertMatchesFilterLabels(&a.Alert, matchers) {
-			continue
-		}
-
-		// Continue if the alert is resolved.
-		if !a.Alert.EndsAt.IsZero() && a.Alert.EndsAt.Before(time.Now()) {
-			continue
-		}
-
-		status := api.getAlertStatus(a.Fingerprint())
-
-		if !showActive && status.State == types.AlertStateActive {
-			continue
-		}
-
-		if !showUnprocessed && status.State == types.AlertStateUnprocessed {
-			continue
-		}
-
-		if !showSilenced && len(status.SilencedBy) != 0 {
-			continue
-		}
-
-		if !showInhibited && len(status.InhibitedBy) != 0 {
-			continue
-		}
-
-		alert := &Alert{
-			Alert:       &a.Alert,
-			Status:      status,
-			Receivers:   receivers,
-			Fingerprint: a.Fingerprint().String(),
-		}
-
-		res = append(res, alert)
-	}
-	api.mtx.RUnlock()
-
-	if err != nil {
-		api.respondError(w, apiError{
-			typ: errorInternal,
-			err: err,
-		}, nil)
-		return
-	}
-	sort.Slice(res, func(i, j int) bool {
-		return res[i].Fingerprint < res[j].Fingerprint
-	})
-	api.respond(w, res)
-}
-
-func receiversMatchFilter(receivers []string, filter *regexp.Regexp) bool {
-	for _, r := range receivers {
-		if filter.MatchString(r) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func alertMatchesFilterLabels(a *model.Alert, matchers []*labels.Matcher) bool {
-	sms := make(map[string]string)
-	for name, value := range a.Labels {
-		sms[string(name)] = string(value)
-	}
-	return matchFilterLabels(matchers, sms)
-}
-
-func (api *API) addAlerts(w http.ResponseWriter, r *http.Request) {
-	var alerts []*types.Alert
-	if err := api.receive(r, &alerts); err != nil {
-		api.respondError(w, apiError{
-			typ: errorBadData,
-			err: err,
-		}, nil)
-		return
-	}
-
-	api.insertAlerts(w, r, alerts...)
-}
-
-func (api *API) insertAlerts(w http.ResponseWriter, r *http.Request, alerts ...*types.Alert) {
-	now := time.Now()
-
-	api.mtx.RLock()
-	resolveTimeout := time.Duration(api.config.Global.ResolveTimeout)
-	api.mtx.RUnlock()
-
-	for _, alert := range alerts {
-		alert.UpdatedAt = now
-
-		// Ensure StartsAt is set.
-		if alert.StartsAt.IsZero() {
-			if alert.EndsAt.IsZero() {
-				alert.StartsAt = now
-			} else {
-				alert.StartsAt = alert.EndsAt
-			}
-		}
-		// If no end time is defined, set a timeout after which an alert
-		// is marked resolved if it is not updated.
-		if alert.EndsAt.IsZero() {
-			alert.Timeout = true
-			alert.EndsAt = now.Add(resolveTimeout)
-		}
-		if alert.EndsAt.After(time.Now()) {
-			api.m.Firing().Inc()
-		} else {
-			api.m.Resolved().Inc()
-		}
-	}
-
-	// Make a best effort to insert all alerts that are valid.
-	var (
-		validAlerts    = make([]*types.Alert, 0, len(alerts))
-		validationErrs = &types.MultiError{}
-	)
-	for _, a := range alerts {
-		removeEmptyLabels(a.Labels)
-
-		if err := a.Validate(); err != nil {
-			validationErrs.Add(err)
-			api.m.Invalid().Inc()
-			continue
-		}
-		validAlerts = append(validAlerts, a)
-	}
-	if err := api.alerts.Put(validAlerts...); err != nil {
-		api.respondError(w, apiError{
-			typ: errorInternal,
-			err: err,
-		}, nil)
-		return
-	}
-
-	if validationErrs.Len() > 0 {
-		api.respondError(w, apiError{
-			typ: errorBadData,
-			err: validationErrs,
-		}, nil)
-		return
-	}
-
-	api.respond(w, nil)
-}
-
-func removeEmptyLabels(ls model.LabelSet) {
-	for k, v := range ls {
-		if string(v) == "" {
-			delete(ls, k)
-		}
-	}
-}
-
-func (api *API) setSilence(w http.ResponseWriter, r *http.Request) {
-	var sil types.Silence
-	if err := api.receive(r, &sil); err != nil {
-		api.respondError(w, apiError{
-			typ: errorBadData,
-			err: err,
-		}, nil)
-		return
-	}
-
-	// This is an API only validation, it cannot be done internally
-	// because the expired silence is semantically important.
-	// But one should not be able to create expired silences, that
-	// won't have any use.
-	if sil.Expired() {
-		api.respondError(w, apiError{
-			typ: errorBadData,
-			err: errors.New("start time must not be equal to end time"),
-		}, nil)
-		return
-	}
-
-	if sil.EndsAt.Before(time.Now()) {
-		api.respondError(w, apiError{
-			typ: errorBadData,
-			err: errors.New("end time can't be in the past"),
-		}, nil)
-		return
-	}
-
-	psil, err := silenceToProto(&sil)
-	if err != nil {
-		api.respondError(w, apiError{
-			typ: errorBadData,
-			err: err,
-		}, nil)
-		return
-	}
-
-	sid, err := api.silences.Set(psil)
-	if err != nil {
-		api.respondError(w, apiError{
-			typ: errorBadData,
-			err: err,
-		}, nil)
-		return
-	}
-
-	api.respond(w, struct {
-		SilenceID string `json:"silenceId"`
-	}{
-		SilenceID: sid,
-	})
-}
-
-func (api *API) getSilence(w http.ResponseWriter, r *http.Request) {
-	sid := route.Param(r.Context(), "sid")
-
-	sils, _, err := api.silences.Query(silence.QIDs(sid))
-	if err != nil || len(sils) == 0 {
-		http.Error(w, fmt.Sprint("Error getting silence: ", err), http.StatusNotFound)
-		return
-	}
-	sil, err := silenceFromProto(sils[0])
-	if err != nil {
-		api.respondError(w, apiError{
-			typ: errorInternal,
-			err: err,
-		}, nil)
-		return
-	}
-
-	api.respond(w, sil)
-}
-
-func (api *API) delSilence(w http.ResponseWriter, r *http.Request) {
-	sid := route.Param(r.Context(), "sid")
-
-	if err := api.silences.Expire(sid); err != nil {
-		api.respondError(w, apiError{
-			typ: errorBadData,
-			err: err,
-		}, nil)
-		return
-	}
-	api.respond(w, nil)
-}
-
-func (api *API) listSilences(w http.ResponseWriter, r *http.Request) {
-	psils, _, err := api.silences.Query()
-	if err != nil {
-		api.respondError(w, apiError{
-			typ: errorInternal,
-			err: err,
-		}, nil)
-		return
-	}
-
-	matchers := []*labels.Matcher{}
-	if filter := r.FormValue("filter"); filter != "" {
-		matchers, err = labels.ParseMatchers(filter)
-		if err != nil {
-			api.respondError(w, apiError{
-				typ: errorBadData,
-				err: err,
-			}, nil)
-			return
-		}
-	}
-
-	sils := []*types.Silence{}
-	for _, ps := range psils {
-		s, err := silenceFromProto(ps)
-		if err != nil {
-			api.respondError(w, apiError{
-				typ: errorInternal,
-				err: err,
-			}, nil)
-			return
-		}
-
-		if !silenceMatchesFilterLabels(s, matchers) {
-			continue
-		}
-		sils = append(sils, s)
-	}
-
-	var active, pending, expired []*types.Silence
-
-	for _, s := range sils {
-		switch s.Status.State {
-		case types.SilenceStateActive:
-			active = append(active, s)
-		case types.SilenceStatePending:
-			pending = append(pending, s)
-		case types.SilenceStateExpired:
-			expired = append(expired, s)
-		}
-	}
-
-	sort.Slice(active, func(i int, j int) bool {
-		return active[i].EndsAt.Before(active[j].EndsAt)
-	})
-	sort.Slice(pending, func(i int, j int) bool {
-		return pending[i].StartsAt.Before(pending[j].EndsAt)
-	})
-	sort.Slice(expired, func(i int, j int) bool {
-		return expired[i].EndsAt.After(expired[j].EndsAt)
-	})
-
-	// Initialize silences explicitly to an empty list (instead of nil)
-	// So that it does not get converted to "null" in JSON.
-	silences := []*types.Silence{}
-	silences = append(silences, active...)
-	silences = append(silences, pending...)
-	silences = append(silences, expired...)
-
-	api.respond(w, silences)
-}
-
-func silenceMatchesFilterLabels(s *types.Silence, matchers []*labels.Matcher) bool {
-	sms := make(map[string]string)
-	for _, m := range s.Matchers {
-		sms[m.Name] = m.Value
-	}
-
-	return matchFilterLabels(matchers, sms)
-}
-
-func matchFilterLabels(matchers []*labels.Matcher, sms map[string]string) bool {
-	for _, m := range matchers {
-		v, prs := sms[m.Name]
-		switch m.Type {
-		case labels.MatchNotRegexp, labels.MatchNotEqual:
-			if string(m.Value) == "" && prs {
-				continue
-			}
-			if !m.Matches(string(v)) {
-				return false
-			}
-		default:
-			if string(m.Value) == "" && !prs {
-				continue
-			}
-			if !prs || !m.Matches(string(v)) {
-				return false
-			}
-		}
-	}
-
-	return true
-}
-
-func silenceToProto(s *types.Silence) (*silencepb.Silence, error) {
-	sil := &silencepb.Silence{
-		Id:        s.ID,
-		StartsAt:  s.StartsAt,
-		EndsAt:    s.EndsAt,
-		UpdatedAt: s.UpdatedAt,
-		Comment:   s.Comment,
-		CreatedBy: s.CreatedBy,
-	}
-	for _, m := range s.Matchers {
-		matcher := &silencepb.Matcher{
-			Name:    m.Name,
-			Pattern: m.Value,
-			Type:    silencepb.Matcher_EQUAL,
-		}
-		if m.IsRegex {
-			matcher.Type = silencepb.Matcher_REGEXP
-		}
-		sil.Matchers = append(sil.Matchers, matcher)
-	}
-	return sil, nil
-}
-
-func silenceFromProto(s *silencepb.Silence) (*types.Silence, error) {
-	sil := &types.Silence{
-		ID:        s.Id,
-		StartsAt:  s.StartsAt,
-		EndsAt:    s.EndsAt,
-		UpdatedAt: s.UpdatedAt,
-		Status: types.SilenceStatus{
-			State: types.CalcSilenceState(s.StartsAt, s.EndsAt),
-		},
-		Comment:   s.Comment,
-		CreatedBy: s.CreatedBy,
-	}
-	for _, m := range s.Matchers {
-		matcher := &types.Matcher{
-			Name:  m.Name,
-			Value: m.Pattern,
-		}
-		switch m.Type {
-		case silencepb.Matcher_EQUAL:
-		case silencepb.Matcher_REGEXP:
-			matcher.IsRegex = true
-		default:
-			return nil, fmt.Errorf("unknown matcher type")
-		}
-		sil.Matchers = append(sil.Matchers, matcher)
-	}
-
-	return sil, nil
-}
-
-type status string
-
-const (
-	statusSuccess status = "success"
-	statusError   status = "error"
-)
-
-type response struct {
-	Status    status      `json:"status"`
-	Data      interface{} `json:"data,omitempty"`
-	ErrorType errorType   `json:"errorType,omitempty"`
-	Error     string      `json:"error,omitempty"`
-}
-
-func (api *API) respond(w http.ResponseWriter, data interface{}) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(200)
-
-	b, err := json.Marshal(&response{
-		Status: statusSuccess,
-		Data:   data,
-	})
-	if err != nil {
-		level.Error(api.logger).Log("msg", "Error marshaling JSON", "err", err)
-		return
-	}
-
-	if _, err := w.Write(b); err != nil {
-		level.Error(api.logger).Log("msg", "failed to write data to connection", "err", err)
-	}
-}
-
-func (api *API) respondError(w http.ResponseWriter, apiErr apiError, data interface{}) {
-	w.Header().Set("Content-Type", "application/json")
-
-	switch apiErr.typ {
-	case errorBadData:
-		w.WriteHeader(http.StatusBadRequest)
-	case errorInternal:
-		w.WriteHeader(http.StatusInternalServerError)
-	default:
-		panic(fmt.Sprintf("unknown error type %q", apiErr.Error()))
-	}
-
-	b, err := json.Marshal(&response{
-		Status:    statusError,
-		ErrorType: apiErr.typ,
-		Error:     apiErr.err.Error(),
-		Data:      data,
-	})
-	if err != nil {
-		return
-	}
-	level.Error(api.logger).Log("msg", "API error", "err", apiErr.Error())
-
-	if _, err := w.Write(b); err != nil {
-		level.Error(api.logger).Log("msg", "failed to write data to connection", "err", err)
-	}
-}
-
-func (api *API) receive(r *http.Request, v interface{}) error {
-	dec := json.NewDecoder(r.Body)
-	defer r.Body.Close()
-
-	err := dec.Decode(v)
-	if err != nil {
-		level.Debug(api.logger).Log("msg", "Decoding request failed", "err", err)
-		return err
-	}
-	return nil
-}
diff --git a/api/v1/api_test.go b/api/v1/api_test.go
deleted file mode 100644
index d25f362..0000000
--- a/api/v1/api_test.go
+++ /dev/null
@@ -1,581 +0,0 @@
-// Copyright 2018 Prometheus Team
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package v1
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"regexp"
-	"testing"
-	"time"
-
-	"github.com/prometheus/common/model"
-	"github.com/stretchr/testify/require"
-
-	"github.com/prometheus/alertmanager/config"
-	"github.com/prometheus/alertmanager/dispatch"
-	"github.com/prometheus/alertmanager/pkg/labels"
-	"github.com/prometheus/alertmanager/provider"
-	"github.com/prometheus/alertmanager/types"
-)
-
-// fakeAlerts is a struct implementing the provider.Alerts interface for tests.
-type fakeAlerts struct {
-	fps    map[model.Fingerprint]int
-	alerts []*types.Alert
-	err    error
-}
-
-func newFakeAlerts(alerts []*types.Alert, withErr bool) *fakeAlerts {
-	fps := make(map[model.Fingerprint]int)
-	for i, a := range alerts {
-		fps[a.Fingerprint()] = i
-	}
-	f := &fakeAlerts{
-		alerts: alerts,
-		fps:    fps,
-	}
-	if withErr {
-		f.err = errors.New("error occurred")
-	}
-	return f
-}
-
-func (f *fakeAlerts) Subscribe() provider.AlertIterator           { return nil }
-func (f *fakeAlerts) Get(model.Fingerprint) (*types.Alert, error) { return nil, nil }
-func (f *fakeAlerts) Put(alerts ...*types.Alert) error {
-	return f.err
-}
-func (f *fakeAlerts) GetPending() provider.AlertIterator {
-	ch := make(chan *types.Alert)
-	done := make(chan struct{})
-	go func() {
-		defer close(ch)
-		for _, a := range f.alerts {
-			ch <- a
-		}
-	}()
-	return provider.NewAlertIterator(ch, done, f.err)
-}
-
-func newGetAlertStatus(f *fakeAlerts) func(model.Fingerprint) types.AlertStatus {
-	return func(fp model.Fingerprint) types.AlertStatus {
-		status := types.AlertStatus{SilencedBy: []string{}, InhibitedBy: []string{}}
-
-		i, ok := f.fps[fp]
-		if !ok {
-			return status
-		}
-		alert := f.alerts[i]
-		switch alert.Labels["state"] {
-		case "active":
-			status.State = types.AlertStateActive
-		case "unprocessed":
-			status.State = types.AlertStateUnprocessed
-		case "suppressed":
-			status.State = types.AlertStateSuppressed
-		}
-		if alert.Labels["silenced_by"] != "" {
-			status.SilencedBy = append(status.SilencedBy, string(alert.Labels["silenced_by"]))
-		}
-		if alert.Labels["inhibited_by"] != "" {
-			status.InhibitedBy = append(status.InhibitedBy, string(alert.Labels["inhibited_by"]))
-		}
-		return status
-	}
-}
-
-func TestAddAlerts(t *testing.T) {
-	now := func(offset int) time.Time {
-		return time.Now().Add(time.Duration(offset) * time.Second)
-	}
-
-	for i, tc := range []struct {
-		start, end time.Time
-		err        bool
-		code       int
-	}{
-		{time.Time{}, time.Time{}, false, 200},
-		{now(0), time.Time{}, false, 200},
-		{time.Time{}, now(-1), false, 200},
-		{time.Time{}, now(0), false, 200},
-		{time.Time{}, now(1), false, 200},
-		{now(-2), now(-1), false, 200},
-		{now(1), now(2), false, 200},
-		{now(1), now(0), false, 400},
-		{now(0), time.Time{}, true, 500},
-	} {
-		alerts := []model.Alert{{
-			StartsAt:    tc.start,
-			EndsAt:      tc.end,
-			Labels:      model.LabelSet{"label1": "test1"},
-			Annotations: model.LabelSet{"annotation1": "some text"},
-		}}
-		b, err := json.Marshal(&alerts)
-		if err != nil {
-			t.Errorf("Unexpected error %v", err)
-		}
-
-		alertsProvider := newFakeAlerts([]*types.Alert{}, tc.err)
-		api := New(alertsProvider, nil, newGetAlertStatus(alertsProvider), nil, nil, nil)
-		defaultGlobalConfig := config.DefaultGlobalConfig()
-		route := config.Route{}
-		api.Update(&config.Config{
-			Global: &defaultGlobalConfig,
-			Route:  &route,
-		})
-
-		r, err := http.NewRequest("POST", "/api/v1/alerts", bytes.NewReader(b))
-		w := httptest.NewRecorder()
-		if err != nil {
-			t.Errorf("Unexpected error %v", err)
-		}
-
-		api.addAlerts(w, r)
-		res := w.Result()
-		body, _ := ioutil.ReadAll(res.Body)
-
-		require.Equal(t, tc.code, w.Code, fmt.Sprintf("test case: %d, StartsAt %v, EndsAt %v, Response: %s", i, tc.start, tc.end, string(body)))
-	}
-}
-
-func TestListAlerts(t *testing.T) {
-	now := time.Now()
-	alerts := []*types.Alert{
-		&types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{"state": "active", "alertname": "alert1"},
-				StartsAt: now.Add(-time.Minute),
-			},
-		},
-		&types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{"state": "unprocessed", "alertname": "alert2"},
-				StartsAt: now.Add(-time.Minute),
-			},
-		},
-		&types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{"state": "suppressed", "silenced_by": "abc", "alertname": "alert3"},
-				StartsAt: now.Add(-time.Minute),
-			},
-		},
-		&types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{"state": "suppressed", "inhibited_by": "abc", "alertname": "alert4"},
-				StartsAt: now.Add(-time.Minute),
-			},
-		},
-		&types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{"alertname": "alert5"},
-				StartsAt: now.Add(-2 * time.Minute),
-				EndsAt:   now.Add(-time.Minute),
-			},
-		},
-	}
-
-	for i, tc := range []struct {
-		err    bool
-		params map[string]string
-
-		code   int
-		anames []string
-	}{
-		{
-			false,
-			map[string]string{},
-			200,
-			[]string{"alert1", "alert2", "alert3", "alert4"},
-		},
-		{
-			false,
-			map[string]string{"active": "true", "unprocessed": "true", "silenced": "true", "inhibited": "true"},
-			200,
-			[]string{"alert1", "alert2", "alert3", "alert4"},
-		},
-		{
-			false,
-			map[string]string{"active": "false", "unprocessed": "true", "silenced": "true", "inhibited": "true"},
-			200,
-			[]string{"alert2", "alert3", "alert4"},
-		},
-		{
-			false,
-			map[string]string{"active": "true", "unprocessed": "false", "silenced": "true", "inhibited": "true"},
-			200,
-			[]string{"alert1", "alert3", "alert4"},
-		},
-		{
-			false,
-			map[string]string{"active": "true", "unprocessed": "true", "silenced": "false", "inhibited": "true"},
-			200,
-			[]string{"alert1", "alert2", "alert4"},
-		},
-		{
-			false,
-			map[string]string{"active": "true", "unprocessed": "true", "silenced": "true", "inhibited": "false"},
-			200,
-			[]string{"alert1", "alert2", "alert3"},
-		},
-		{
-			false,
-			map[string]string{"filter": "{alertname=\"alert3\""},
-			200,
-			[]string{"alert3"},
-		},
-		{
-			false,
-			map[string]string{"filter": "{alertname"},
-			400,
-			[]string{},
-		},
-		{
-			false,
-			map[string]string{"receiver": "other"},
-			200,
-			[]string{},
-		},
-		{
-			false,
-			map[string]string{"active": "invalid"},
-			400,
-			[]string{},
-		},
-		{
-			true,
-			map[string]string{},
-			500,
-			[]string{},
-		},
-	} {
-		alertsProvider := newFakeAlerts(alerts, tc.err)
-		api := New(alertsProvider, nil, newGetAlertStatus(alertsProvider), nil, nil, nil)
-		api.route = dispatch.NewRoute(&config.Route{Receiver: "def-receiver"}, nil)
-
-		r, err := http.NewRequest("GET", "/api/v1/alerts", nil)
-		if err != nil {
-			t.Fatalf("Unexpected error %v", err)
-		}
-		q := r.URL.Query()
-		for k, v := range tc.params {
-			q.Add(k, v)
-		}
-		r.URL.RawQuery = q.Encode()
-		w := httptest.NewRecorder()
-
-		api.listAlerts(w, r)
-		body, _ := ioutil.ReadAll(w.Result().Body)
-
-		var res response
-		err = json.Unmarshal(body, &res)
-		if err != nil {
-			t.Fatalf("Unexpected error %v", err)
-		}
-
-		require.Equal(t, tc.code, w.Code, fmt.Sprintf("test case: %d, response: %s", i, string(body)))
-		if w.Code != 200 {
-			continue
-		}
-
-		// Data needs to be serialized/deserialized to be converted to the real type.
-		b, err := json.Marshal(res.Data)
-		if err != nil {
-			t.Fatalf("Unexpected error %v", err)
-		}
-		retAlerts := []*Alert{}
-		err = json.Unmarshal(b, &retAlerts)
-		if err != nil {
-			t.Fatalf("Unexpected error %v", err)
-		}
-
-		anames := []string{}
-		for _, a := range retAlerts {
-			name, ok := a.Labels["alertname"]
-			if ok {
-				anames = append(anames, string(name))
-			}
-		}
-		require.Equal(t, tc.anames, anames, fmt.Sprintf("test case: %d, alert names are not equal", i))
-	}
-}
-
-func TestAlertFiltering(t *testing.T) {
-	type test struct {
-		alert    *model.Alert
-		msg      string
-		expected bool
-	}
-
-	// Equal
-	equal, err := labels.NewMatcher(labels.MatchEqual, "label1", "test1")
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	tests := []test{
-		{&model.Alert{Labels: model.LabelSet{"label1": "test1"}}, "label1=test1", true},
-		{&model.Alert{Labels: model.LabelSet{"label1": "test2"}}, "label1=test2", false},
-		{&model.Alert{Labels: model.LabelSet{"label2": "test2"}}, "label2=test2", false},
-	}
-
-	for _, test := range tests {
-		actual := alertMatchesFilterLabels(test.alert, []*labels.Matcher{equal})
-		msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg)
-		require.Equal(t, test.expected, actual, msg)
-	}
-
-	// Not Equal
-	notEqual, err := labels.NewMatcher(labels.MatchNotEqual, "label1", "test1")
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	tests = []test{
-		{&model.Alert{Labels: model.LabelSet{"label1": "test1"}}, "label1!=test1", false},
-		{&model.Alert{Labels: model.LabelSet{"label1": "test2"}}, "label1!=test2", true},
-		{&model.Alert{Labels: model.LabelSet{"label2": "test2"}}, "label2!=test2", true},
-	}
-
-	for _, test := range tests {
-		actual := alertMatchesFilterLabels(test.alert, []*labels.Matcher{notEqual})
-		msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg)
-		require.Equal(t, test.expected, actual, msg)
-	}
-
-	// Regexp Equal
-	regexpEqual, err := labels.NewMatcher(labels.MatchRegexp, "label1", "tes.*")
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	tests = []test{
-		{&model.Alert{Labels: model.LabelSet{"label1": "test1"}}, "label1=~test1", true},
-		{&model.Alert{Labels: model.LabelSet{"label1": "test2"}}, "label1=~test2", true},
-		{&model.Alert{Labels: model.LabelSet{"label2": "test2"}}, "label2=~test2", false},
-	}
-
-	for _, test := range tests {
-		actual := alertMatchesFilterLabels(test.alert, []*labels.Matcher{regexpEqual})
-		msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg)
-		require.Equal(t, test.expected, actual, msg)
-	}
-
-	// Regexp Not Equal
-	regexpNotEqual, err := labels.NewMatcher(labels.MatchNotRegexp, "label1", "tes.*")
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	tests = []test{
-		{&model.Alert{Labels: model.LabelSet{"label1": "test1"}}, "label1!~test1", false},
-		{&model.Alert{Labels: model.LabelSet{"label1": "test2"}}, "label1!~test2", false},
-		{&model.Alert{Labels: model.LabelSet{"label2": "test2"}}, "label2!~test2", true},
-	}
-
-	for _, test := range tests {
-		actual := alertMatchesFilterLabels(test.alert, []*labels.Matcher{regexpNotEqual})
-		msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg)
-		require.Equal(t, test.expected, actual, msg)
-	}
-}
-
-func TestSilenceFiltering(t *testing.T) {
-	type test struct {
-		silence  *types.Silence
-		msg      string
-		expected bool
-	}
-
-	// Equal
-	equal, err := labels.NewMatcher(labels.MatchEqual, "label1", "test1")
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	tests := []test{
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test1"})},
-			"label1=test1",
-			true,
-		},
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test2"})},
-			"label1=test2",
-			false,
-		},
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label2": "test2"})},
-			"label2=test2",
-			false,
-		},
-	}
-
-	for _, test := range tests {
-		actual := silenceMatchesFilterLabels(test.silence, []*labels.Matcher{equal})
-		msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg)
-		require.Equal(t, test.expected, actual, msg)
-	}
-
-	// Not Equal
-	notEqual, err := labels.NewMatcher(labels.MatchNotEqual, "label1", "test1")
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	tests = []test{
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test1"})},
-			"label1!=test1",
-			false,
-		},
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test2"})},
-			"label1!=test2",
-			true,
-		},
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label2": "test2"})},
-			"label2!=test2",
-			true,
-		},
-	}
-
-	for _, test := range tests {
-		actual := silenceMatchesFilterLabels(test.silence, []*labels.Matcher{notEqual})
-		msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg)
-		require.Equal(t, test.expected, actual, msg)
-	}
-
-	// Regexp Equal
-	regexpEqual, err := labels.NewMatcher(labels.MatchRegexp, "label1", "tes.*")
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	tests = []test{
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test1"})},
-			"label1=~test1",
-			true,
-		},
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test2"})},
-			"label1=~test2",
-			true,
-		},
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label2": "test2"})},
-			"label2=~test2",
-			false,
-		},
-	}
-
-	for _, test := range tests {
-		actual := silenceMatchesFilterLabels(test.silence, []*labels.Matcher{regexpEqual})
-		msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg)
-		require.Equal(t, test.expected, actual, msg)
-	}
-
-	// Regexp Not Equal
-	regexpNotEqual, err := labels.NewMatcher(labels.MatchNotRegexp, "label1", "tes.*")
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	tests = []test{
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test1"})},
-			"label1!~test1",
-			false,
-		},
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label1": "test2"})},
-			"label1!~test2",
-			false,
-		},
-		{
-			&types.Silence{Matchers: newMatcher(model.LabelSet{"label2": "test2"})},
-			"label2!~test2",
-			true,
-		},
-	}
-
-	for _, test := range tests {
-		actual := silenceMatchesFilterLabels(test.silence, []*labels.Matcher{regexpNotEqual})
-		msg := fmt.Sprintf("Expected %t for %s", test.expected, test.msg)
-		require.Equal(t, test.expected, actual, msg)
-	}
-}
-
-func TestReceiversMatchFilter(t *testing.T) {
-	receivers := []string{"pagerduty", "slack", "pushover"}
-
-	filter, err := regexp.Compile(fmt.Sprintf("^(?:%s)$", "push.*"))
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-	require.True(t, receiversMatchFilter(receivers, filter))
-
-	filter, err = regexp.Compile(fmt.Sprintf("^(?:%s)$", "push"))
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-	require.False(t, receiversMatchFilter(receivers, filter))
-}
-
-func TestMatchFilterLabels(t *testing.T) {
-	testCases := []struct {
-		matcher  labels.MatchType
-		expected bool
-	}{
-		{labels.MatchEqual, true},
-		{labels.MatchRegexp, true},
-		{labels.MatchNotEqual, false},
-		{labels.MatchNotRegexp, false},
-	}
-
-	for _, tc := range testCases {
-		l, err := labels.NewMatcher(tc.matcher, "foo", "")
-		require.NoError(t, err)
-		sms := map[string]string{
-			"baz": "bar",
-		}
-		ls := []*labels.Matcher{l}
-
-		require.Equal(t, tc.expected, matchFilterLabels(ls, sms))
-
-		l, err = labels.NewMatcher(tc.matcher, "foo", "")
-		require.NoError(t, err)
-		sms = map[string]string{
-			"baz": "bar",
-			"foo": "quux",
-		}
-		ls = []*labels.Matcher{l}
-		require.NotEqual(t, tc.expected, matchFilterLabels(ls, sms))
-	}
-}
-
-func newMatcher(labelSet model.LabelSet) types.Matchers {
-	matchers := make([]*types.Matcher, 0, len(labelSet))
-	for key, val := range labelSet {
-		matchers = append(matchers, types.NewMatcher(key, string(val)))
-	}
-	return matchers
-}
diff --git a/api/v2/api.go b/api/v2/api.go
deleted file mode 100644
index 6cde197..0000000
--- a/api/v2/api.go
+++ /dev/null
@@ -1,798 +0,0 @@
-// Copyright 2018 Prometheus Team
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package v2
-
-import (
-	"fmt"
-	"net/http"
-	"regexp"
-	"sort"
-	"sync"
-	"time"
-
-	"github.com/go-kit/kit/log"
-	"github.com/go-kit/kit/log/level"
-	"github.com/go-openapi/loads"
-	"github.com/go-openapi/runtime/middleware"
-	"github.com/go-openapi/strfmt"
-	"github.com/prometheus/client_golang/prometheus"
-	prometheus_model "github.com/prometheus/common/model"
-	"github.com/prometheus/common/version"
-	"github.com/rs/cors"
-
-	"github.com/prometheus/alertmanager/api/metrics"
-	open_api_models "github.com/prometheus/alertmanager/api/v2/models"
-	"github.com/prometheus/alertmanager/api/v2/restapi"
-	"github.com/prometheus/alertmanager/api/v2/restapi/operations"
-	alert_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/alert"
-	alertgroup_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/alertgroup"
-	general_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/general"
-	receiver_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/receiver"
-	silence_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/silence"
-	"github.com/prometheus/alertmanager/cluster"
-	"github.com/prometheus/alertmanager/config"
-	"github.com/prometheus/alertmanager/dispatch"
-	"github.com/prometheus/alertmanager/pkg/labels"
-	"github.com/prometheus/alertmanager/provider"
-	"github.com/prometheus/alertmanager/silence"
-	"github.com/prometheus/alertmanager/silence/silencepb"
-	"github.com/prometheus/alertmanager/types"
-)
-
-// API represents an Alertmanager API v2
-type API struct {
-	peer           *cluster.Peer
-	silences       *silence.Silences
-	alerts         provider.Alerts
-	alertGroups    groupsFn
-	getAlertStatus getAlertStatusFn
-	uptime         time.Time
-
-	// mtx protects alertmanagerConfig, setAlertStatus and route.
-	mtx sync.RWMutex
-	// resolveTimeout represents the default resolve timeout that an alert is
-	// assigned if no end time is specified.
-	alertmanagerConfig *config.Config
-	route              *dispatch.Route
-	setAlertStatus     setAlertStatusFn
-
-	logger log.Logger
-	m      *metrics.Alerts
-
-	Handler http.Handler
-}
-
-type groupsFn func(func(*dispatch.Route) bool, func(*types.Alert, time.Time) bool) (dispatch.AlertGroups, map[prometheus_model.Fingerprint][]string)
-type getAlertStatusFn func(prometheus_model.Fingerprint) types.AlertStatus
-type setAlertStatusFn func(prometheus_model.LabelSet)
-
-// NewAPI returns a new Alertmanager API v2
-func NewAPI(
-	alerts provider.Alerts,
-	gf groupsFn,
-	sf getAlertStatusFn,
-	silences *silence.Silences,
-	peer *cluster.Peer,
-	l log.Logger,
-	r prometheus.Registerer,
-) (*API, error) {
-	api := API{
-		alerts:         alerts,
-		getAlertStatus: sf,
-		alertGroups:    gf,
-		peer:           peer,
-		silences:       silences,
-		logger:         l,
-		m:              metrics.NewAlerts("v2", r),
-		uptime:         time.Now(),
-	}
-
-	// Load embedded swagger file.
-	swaggerSpec, err := loads.Analyzed(restapi.SwaggerJSON, "")
-	if err != nil {
-		return nil, fmt.Errorf("failed to load embedded swagger file: %v", err.Error())
-	}
-
-	// Create new service API.
-	openAPI := operations.NewAlertmanagerAPI(swaggerSpec)
-
-	// Skip the  redoc middleware, only serving the OpenAPI specification and
-	// the API itself via RoutesHandler. See:
-	// https://github.com/go-swagger/go-swagger/issues/1779
-	openAPI.Middleware = func(b middleware.Builder) http.Handler {
-		return middleware.Spec("", swaggerSpec.Raw(), openAPI.Context().RoutesHandler(b))
-	}
-
-	openAPI.AlertGetAlertsHandler = alert_ops.GetAlertsHandlerFunc(api.getAlertsHandler)
-	openAPI.AlertPostAlertsHandler = alert_ops.PostAlertsHandlerFunc(api.postAlertsHandler)
-	openAPI.AlertgroupGetAlertGroupsHandler = alertgroup_ops.GetAlertGroupsHandlerFunc(api.getAlertGroupsHandler)
-	openAPI.GeneralGetStatusHandler = general_ops.GetStatusHandlerFunc(api.getStatusHandler)
-	openAPI.ReceiverGetReceiversHandler = receiver_ops.GetReceiversHandlerFunc(api.getReceiversHandler)
-	openAPI.SilenceDeleteSilenceHandler = silence_ops.DeleteSilenceHandlerFunc(api.deleteSilenceHandler)
-	openAPI.SilenceGetSilenceHandler = silence_ops.GetSilenceHandlerFunc(api.getSilenceHandler)
-	openAPI.SilenceGetSilencesHandler = silence_ops.GetSilencesHandlerFunc(api.getSilencesHandler)
-	openAPI.SilencePostSilencesHandler = silence_ops.PostSilencesHandlerFunc(api.postSilencesHandler)
-
-	handleCORS := cors.Default().Handler
-	api.Handler = handleCORS(openAPI.Serve(nil))
-
-	return &api, nil
-}
-
-func (api *API) requestLogger(req *http.Request) log.Logger {
-	return log.With(api.logger, "path", req.URL.Path, "method", req.Method)
-}
-
-// Update sets the API struct members that may change between reloads of alertmanager.
-func (api *API) Update(cfg *config.Config, setAlertStatus setAlertStatusFn) {
-	api.mtx.Lock()
-	defer api.mtx.Unlock()
-
-	api.alertmanagerConfig = cfg
-	api.route = dispatch.NewRoute(cfg.Route, nil)
-	api.setAlertStatus = setAlertStatus
-}
-
-func (api *API) getStatusHandler(params general_ops.GetStatusParams) middleware.Responder {
-	api.mtx.RLock()
-	defer api.mtx.RUnlock()
-
-	original := api.alertmanagerConfig.String()
-	uptime := strfmt.DateTime(api.uptime)
-
-	status := open_api_models.ClusterStatusStatusDisabled
-
-	resp := open_api_models.AlertmanagerStatus{
-		Uptime: &uptime,
-		VersionInfo: &open_api_models.VersionInfo{
-			Version:   &version.Version,
-			Revision:  &version.Revision,
-			Branch:    &version.Branch,
-			BuildUser: &version.BuildUser,
-			BuildDate: &version.BuildDate,
-			GoVersion: &version.GoVersion,
-		},
-		Config: &open_api_models.AlertmanagerConfig{
-			Original: &original,
-		},
-		Cluster: &open_api_models.ClusterStatus{
-			Status: &status,
-			Peers:  []*open_api_models.PeerStatus{},
-		},
-	}
-
-	// If alertmanager cluster feature is disabled, then api.peers == nil.
-	if api.peer != nil {
-		status := api.peer.Status()
-
-		peers := []*open_api_models.PeerStatus{}
-		for _, n := range api.peer.Peers() {
-			address := n.Address()
-			peers = append(peers, &open_api_models.PeerStatus{
-				Name:    &n.Name,
-				Address: &address,
-			})
-		}
-
-		sort.Slice(peers, func(i, j int) bool {
-			return *peers[i].Name < *peers[j].Name
-		})
-
-		resp.Cluster = &open_api_models.ClusterStatus{
-			Name:   api.peer.Name(),
-			Status: &status,
-			Peers:  peers,
-		}
-	}
-
-	return general_ops.NewGetStatusOK().WithPayload(&resp)
-}
-
-func (api *API) getReceiversHandler(params receiver_ops.GetReceiversParams) middleware.Responder {
-	api.mtx.RLock()
-	defer api.mtx.RUnlock()
-
-	receivers := make([]*open_api_models.Receiver, 0, len(api.alertmanagerConfig.Receivers))
-	for _, r := range api.alertmanagerConfig.Receivers {
-		receivers = append(receivers, &open_api_models.Receiver{Name: &r.Name})
-	}
-
-	return receiver_ops.NewGetReceiversOK().WithPayload(receivers)
-}
-
-func (api *API) getAlertsHandler(params alert_ops.GetAlertsParams) middleware.Responder {
-	var (
-		receiverFilter *regexp.Regexp
-		// Initialize result slice to prevent api returning `null` when there
-		// are no alerts present
-		res = open_api_models.GettableAlerts{}
-		ctx = params.HTTPRequest.Context()
-
-		logger = api.requestLogger(params.HTTPRequest)
-	)
-
-	matchers, err := parseFilter(params.Filter)
-	if err != nil {
-		level.Error(logger).Log("msg", "Failed to parse matchers", "err", err)
-		return alertgroup_ops.NewGetAlertGroupsBadRequest().WithPayload(err.Error())
-	}
-
-	if params.Receiver != nil {
-		receiverFilter, err = regexp.Compile("^(?:" + *params.Receiver + ")$")
-		if err != nil {
-			level.Error(logger).Log("msg", "Failed to compile receiver regex", "err", err)
-			return alert_ops.
-				NewGetAlertsBadRequest().
-				WithPayload(
-					fmt.Sprintf("failed to parse receiver param: %v", err.Error()),
-				)
-		}
-	}
-
-	alerts := api.alerts.GetPending()
-	defer alerts.Close()
-
-	alertFilter := api.alertFilter(matchers, *params.Silenced, *params.Inhibited, *params.Active)
-	now := time.Now()
-
-	api.mtx.RLock()
-	for a := range alerts.Next() {
-		if err = alerts.Err(); err != nil {
-			break
-		}
-		if err = ctx.Err(); err != nil {
-			break
-		}
-
-		routes := api.route.Match(a.Labels)
-		receivers := make([]string, 0, len(routes))
-		for _, r := range routes {
-			receivers = append(receivers, r.RouteOpts.Receiver)
-		}
-
-		if receiverFilter != nil && !receiversMatchFilter(receivers, receiverFilter) {
-			continue
-		}
-
-		if !alertFilter(a, now) {
-			continue
-		}
-
-		alert := alertToOpenAPIAlert(a, api.getAlertStatus(a.Fingerprint()), receivers)
-
-		res = append(res, alert)
-	}
-	api.mtx.RUnlock()
-
-	if err != nil {
-		level.Error(logger).Log("msg", "Failed to get alerts", "err", err)
-		return alert_ops.NewGetAlertsInternalServerError().WithPayload(err.Error())
-	}
-	sort.Slice(res, func(i, j int) bool {
-		return *res[i].Fingerprint < *res[j].Fingerprint
-	})
-
-	return alert_ops.NewGetAlertsOK().WithPayload(res)
-}
-
-func (api *API) postAlertsHandler(params alert_ops.PostAlertsParams) middleware.Responder {
-	logger := api.requestLogger(params.HTTPRequest)
-
-	alerts := openAPIAlertsToAlerts(params.Alerts)
-	now := time.Now()
-
-	api.mtx.RLock()
-	resolveTimeout := time.Duration(api.alertmanagerConfig.Global.ResolveTimeout)
-	api.mtx.RUnlock()
-
-	for _, alert := range alerts {
-		alert.UpdatedAt = now
-
-		// Ensure StartsAt is set.
-		if alert.StartsAt.IsZero() {
-			if alert.EndsAt.IsZero() {
-				alert.StartsAt = now
-			} else {
-				alert.StartsAt = alert.EndsAt
-			}
-		}
-		// If no end time is defined, set a timeout after which an alert
-		// is marked resolved if it is not updated.
-		if alert.EndsAt.IsZero() {
-			alert.Timeout = true
-			alert.EndsAt = now.Add(resolveTimeout)
-		}
-		if alert.EndsAt.After(time.Now()) {
-			api.m.Firing().Inc()
-		} else {
-			api.m.Resolved().Inc()
-		}
-	}
-
-	// Make a best effort to insert all alerts that are valid.
-	var (
-		validAlerts    = make([]*types.Alert, 0, len(alerts))
-		validationErrs = &types.MultiError{}
-	)
-	for _, a := range alerts {
-		removeEmptyLabels(a.Labels)
-
-		if err := a.Validate(); err != nil {
-			validationErrs.Add(err)
-			api.m.Invalid().Inc()
-			continue
-		}
-		validAlerts = append(validAlerts, a)
-	}
-	if err := api.alerts.Put(validAlerts...); err != nil {
-		level.Error(logger).Log("msg", "Failed to create alerts", "err", err)
-		return alert_ops.NewPostAlertsInternalServerError().WithPayload(err.Error())
-	}
-
-	if validationErrs.Len() > 0 {
-		level.Error(logger).Log("msg", "Failed to validate alerts", "err", validationErrs.Error())
-		return alert_ops.NewPostAlertsBadRequest().WithPayload(validationErrs.Error())
-	}
-
-	return alert_ops.NewPostAlertsOK()
-}
-
-func (api *API) getAlertGroupsHandler(params alertgroup_ops.GetAlertGroupsParams) middleware.Responder {
-	logger := api.requestLogger(params.HTTPRequest)
-
-	matchers, err := parseFilter(params.Filter)
-	if err != nil {
-		level.Error(logger).Log("msg", "Failed to parse matchers", "err", err)
-		return alertgroup_ops.NewGetAlertGroupsBadRequest().WithPayload(err.Error())
-	}
-
-	var receiverFilter *regexp.Regexp
-	if params.Receiver != nil {
-		receiverFilter, err = regexp.Compile("^(?:" + *params.Receiver + ")$")
-		if err != nil {
-			level.Error(logger).Log("msg", "Failed to compile receiver regex", "err", err)
-			return alertgroup_ops.
-				NewGetAlertGroupsBadRequest().
-				WithPayload(
-					fmt.Sprintf("failed to parse receiver param: %v", err.Error()),
-				)
-		}
-	}
-
-	rf := func(receiverFilter *regexp.Regexp) func(r *dispatch.Route) bool {
-		return func(r *dispatch.Route) bool {
-			receiver := r.RouteOpts.Receiver
-			if receiverFilter != nil && !receiverFilter.MatchString(receiver) {
-				return false
-			}
-			return true
-		}
-	}(receiverFilter)
-
-	af := api.alertFilter(matchers, *params.Silenced, *params.Inhibited, *params.Active)
-	alertGroups, allReceivers := api.alertGroups(rf, af)
-
-	res := make(open_api_models.AlertGroups, 0, len(alertGroups))
-
-	for _, alertGroup := range alertGroups {
-		ag := &open_api_models.AlertGroup{
-			Receiver: &open_api_models.Receiver{Name: &alertGroup.Receiver},
-			Labels:   modelLabelSetToAPILabelSet(alertGroup.Labels),
-			Alerts:   make([]*open_api_models.GettableAlert, 0, len(alertGroup.Alerts)),
-		}
-
-		for _, alert := range alertGroup.Alerts {
-			fp := alert.Fingerprint()
-			receivers := allReceivers[fp]
-			status := api.getAlertStatus(fp)
-			apiAlert := alertToOpenAPIAlert(alert, status, receivers)
-			ag.Alerts = append(ag.Alerts, apiAlert)
-		}
-		res = append(res, ag)
-	}
-
-	return alertgroup_ops.NewGetAlertGroupsOK().WithPayload(res)
-}
-
-func (api *API) alertFilter(matchers []*labels.Matcher, silenced, inhibited, active bool) func(a *types.Alert, now time.Time) bool {
-	return func(a *types.Alert, now time.Time) bool {
-		if !a.EndsAt.IsZero() && a.EndsAt.Before(now) {
-			return false
-		}
-
-		// Set alert's current status based on its label set.
-		api.setAlertStatus(a.Labels)
-
-		// Get alert's current status after seeing if it is suppressed.
-		status := api.getAlertStatus(a.Fingerprint())
-
-		if !active && status.State == types.AlertStateActive {
-			return false
-		}
-
-		if !silenced && len(status.SilencedBy) != 0 {
-			return false
-		}
-
-		if !inhibited && len(status.InhibitedBy) != 0 {
-			return false
-		}
-
-		return alertMatchesFilterLabels(&a.Alert, matchers)
-	}
-}
-
-func alertToOpenAPIAlert(alert *types.Alert, status types.AlertStatus, receivers []string) *open_api_models.GettableAlert {
-	startsAt := strfmt.DateTime(alert.StartsAt)
-	updatedAt := strfmt.DateTime(alert.UpdatedAt)
-	endsAt := strfmt.DateTime(alert.EndsAt)
-
-	apiReceivers := make([]*open_api_models.Receiver, 0, len(receivers))
-	for i := range receivers {
-		apiReceivers = append(apiReceivers, &open_api_models.Receiver{Name: &receivers[i]})
-	}
-
-	fp := alert.Fingerprint().String()
-	state := string(status.State)
-	aa := &open_api_models.GettableAlert{
-		Alert: open_api_models.Alert{
-			GeneratorURL: strfmt.URI(alert.GeneratorURL),
-			Labels:       modelLabelSetToAPILabelSet(alert.Labels),
-		},
-		Annotations: modelLabelSetToAPILabelSet(alert.Annotations),
-		StartsAt:    &startsAt,
-		UpdatedAt:   &updatedAt,
-		EndsAt:      &endsAt,
-		Fingerprint: &fp,
-		Receivers:   apiReceivers,
-		Status: &open_api_models.AlertStatus{
-			State:       &state,
-			SilencedBy:  status.SilencedBy,
-			InhibitedBy: status.InhibitedBy,
-		},
-	}
-
-	if aa.Status.SilencedBy == nil {
-		aa.Status.SilencedBy = []string{}
-	}
-
-	if aa.Status.InhibitedBy == nil {
-		aa.Status.InhibitedBy = []string{}
-	}
-
-	return aa
-}
-
-func openAPIAlertsToAlerts(apiAlerts open_api_models.PostableAlerts) []*types.Alert {
-	alerts := []*types.Alert{}
-	for _, apiAlert := range apiAlerts {
-		alert := types.Alert{
-			Alert: prometheus_model.Alert{
-				Labels:       apiLabelSetToModelLabelSet(apiAlert.Labels),
-				Annotations:  apiLabelSetToModelLabelSet(apiAlert.Annotations),
-				StartsAt:     time.Time(apiAlert.StartsAt),
-				EndsAt:       time.Time(apiAlert.EndsAt),
-				GeneratorURL: string(apiAlert.GeneratorURL),
-			},
-		}
-		alerts = append(alerts, &alert)
-	}
-
-	return alerts
-}
-
-func removeEmptyLabels(ls prometheus_model.LabelSet) {
-	for k, v := range ls {
-		if string(v) == "" {
-			delete(ls, k)
-		}
-	}
-}
-
-func modelLabelSetToAPILabelSet(modelLabelSet prometheus_model.LabelSet) open_api_models.LabelSet {
-	apiLabelSet := open_api_models.LabelSet{}
-	for key, value := range modelLabelSet {
-		apiLabelSet[string(key)] = string(value)
-	}
-
-	return apiLabelSet
-}
-
-func apiLabelSetToModelLabelSet(apiLabelSet open_api_models.LabelSet) prometheus_model.LabelSet {
-	modelLabelSet := prometheus_model.LabelSet{}
-	for key, value := range apiLabelSet {
-		modelLabelSet[prometheus_model.LabelName(key)] = prometheus_model.LabelValue(value)
-	}
-
-	return modelLabelSet
-}
-
-func receiversMatchFilter(receivers []string, filter *regexp.Regexp) bool {
-	for _, r := range receivers {
-		if filter.MatchString(r) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func alertMatchesFilterLabels(a *prometheus_model.Alert, matchers []*labels.Matcher) bool {
-	sms := make(map[string]string)
-	for name, value := range a.Labels {
-		sms[string(name)] = string(value)
-	}
-	return matchFilterLabels(matchers, sms)
-}
-
-func matchFilterLabels(matchers []*labels.Matcher, sms map[string]string) bool {
-	for _, m := range matchers {
-		v, prs := sms[m.Name]
-		switch m.Type {
-		case labels.MatchNotRegexp, labels.MatchNotEqual:
-			if m.Value == "" && prs {
-				continue
-			}
-			if !m.Matches(v) {
-				return false
-			}
-		default:
-			if m.Value == "" && !prs {
-				continue
-			}
-			if !prs || !m.Matches(v) {
-				return false
-			}
-		}
-	}
-
-	return true
-}
-
-func (api *API) getSilencesHandler(params silence_ops.GetSilencesParams) middleware.Responder {
-	logger := api.requestLogger(params.HTTPRequest)
-
-	matchers := []*labels.Matcher{}
-	if params.Filter != nil {
-		for _, matcherString := range params.Filter {
-			matcher, err := labels.ParseMatcher(matcherString)
-			if err != nil {
-				level.Error(logger).Log("msg", "Failed to parse matchers", "err", err)
-				return alert_ops.NewGetAlertsBadRequest().WithPayload(err.Error())
-			}
-
-			matchers = append(matchers, matcher)
-		}
-	}
-
-	psils, _, err := api.silences.Query()
-	if err != nil {
-		level.Error(logger).Log("msg", "Failed to get silences", "err", err)
-		return silence_ops.NewGetSilencesInternalServerError().WithPayload(err.Error())
-	}
-
-	sils := open_api_models.GettableSilences{}
-	for _, ps := range psils {
-		silence, err := gettableSilenceFromProto(ps)
-		if err != nil {
-			level.Error(logger).Log("msg", "Failed to unmarshal silence from proto", "err", err)
-			return silence_ops.NewGetSilencesInternalServerError().WithPayload(err.Error())
-		}
-		if !gettableSilenceMatchesFilterLabels(silence, matchers) {
-			continue
-		}
-		sils = append(sils, &silence)
-	}
-
-	sortSilences(sils)
-
-	return silence_ops.NewGetSilencesOK().WithPayload(sils)
-}
-
-var (
-	silenceStateOrder = map[types.SilenceState]int{
-		types.SilenceStateActive:  1,
-		types.SilenceStatePending: 2,
-		types.SilenceStateExpired: 3,
-	}
-)
-
-// sortSilences sorts first according to the state "active, pending, expired"
-// then by end time or start time depending on the state.
-// active silences should show the next to expire first
-// pending silences are ordered based on which one starts next
-// expired are ordered based on which one expired most recently
-func sortSilences(sils open_api_models.GettableSilences) {
-	sort.Slice(sils, func(i, j int) bool {
-		state1 := types.SilenceState(*sils[i].Status.State)
-		state2 := types.SilenceState(*sils[j].Status.State)
-		if state1 != state2 {
-			return silenceStateOrder[state1] < silenceStateOrder[state2]
-		}
-		switch state1 {
-		case types.SilenceStateActive:
-			endsAt1 := time.Time(*sils[i].Silence.EndsAt)
-			endsAt2 := time.Time(*sils[j].Silence.EndsAt)
-			return endsAt1.Before(endsAt2)
-		case types.SilenceStatePending:
-			startsAt1 := time.Time(*sils[i].Silence.StartsAt)
-			startsAt2 := time.Time(*sils[j].Silence.StartsAt)
-			return startsAt1.Before(startsAt2)
-		case types.SilenceStateExpired:
-			endsAt1 := time.Time(*sils[i].Silence.EndsAt)
-			endsAt2 := time.Time(*sils[j].Silence.EndsAt)
-			return endsAt1.After(endsAt2)
-		}
-		return false
-	})
-}
-
-func gettableSilenceMatchesFilterLabels(s open_api_models.GettableSilence, matchers []*labels.Matcher) bool {
-	sms := make(map[string]string)
-	for _, m := range s.Matchers {
-		sms[*m.Name] = *m.Value
-	}
-
-	return matchFilterLabels(matchers, sms)
-}
-
-func (api *API) getSilenceHandler(params silence_ops.GetSilenceParams) middleware.Responder {
-	logger := api.requestLogger(params.HTTPRequest)
-
-	sils, _, err := api.silences.Query(silence.QIDs(params.SilenceID.String()))
-	if err != nil {
-		level.Error(logger).Log("msg", "Failed to get silence by id", "err", err, "id", params.SilenceID.String())
-		return silence_ops.NewGetSilenceInternalServerError().WithPayload(err.Error())
-	}
-
-	if len(sils) == 0 {
-		level.Error(logger).Log("msg", "Failed to find silence", "err", err, "id", params.SilenceID.String())
-		return silence_ops.NewGetSilenceNotFound()
-	}
-
-	sil, err := gettableSilenceFromProto(sils[0])
-	if err != nil {
-		level.Error(logger).Log("msg", "Failed to convert unmarshal from proto", "err", err)
-		return silence_ops.NewGetSilenceInternalServerError().WithPayload(err.Error())
-	}
-
-	return silence_ops.NewGetSilenceOK().WithPayload(&sil)
-}
-
-func (api *API) deleteSilenceHandler(params silence_ops.DeleteSilenceParams) middleware.Responder {
-	logger := api.requestLogger(params.HTTPRequest)
-
-	sid := params.SilenceID.String()
-	if err := api.silences.Expire(sid); err != nil {
-		level.Error(logger).Log("msg", "Failed to expire silence", "err", err)
-		return silence_ops.NewDeleteSilenceInternalServerError().WithPayload(err.Error())
-	}
-	return silence_ops.NewDeleteSilenceOK()
-}
-
-func gettableSilenceFromProto(s *silencepb.Silence) (open_api_models.GettableSilence, error) {
-	start := strfmt.DateTime(s.StartsAt)
-	end := strfmt.DateTime(s.EndsAt)
-	updated := strfmt.DateTime(s.UpdatedAt)
-	state := string(types.CalcSilenceState(s.StartsAt, s.EndsAt))
-	sil := open_api_models.GettableSilence{
-		Silence: open_api_models.Silence{
-			StartsAt:  &start,
-			EndsAt:    &end,
-			Comment:   &s.Comment,
-			CreatedBy: &s.CreatedBy,
-		},
-		ID:        &s.Id,
-		UpdatedAt: &updated,
-		Status: &open_api_models.SilenceStatus{
-			State: &state,
-		},
-	}
-
-	for _, m := range s.Matchers {
-		matcher := &open_api_models.Matcher{
-			Name:  &m.Name,
-			Value: &m.Pattern,
-		}
-		switch m.Type {
-		case silencepb.Matcher_EQUAL:
-			f := false
-			matcher.IsRegex = &f
-		case silencepb.Matcher_REGEXP:
-			t := true
-			matcher.IsRegex = &t
-		default:
-			return sil, fmt.Errorf(
-				"unknown matcher type for matcher '%v' in silence '%v'",
-				m.Name,
-				s.Id,
-			)
-		}
-		sil.Matchers = append(sil.Matchers, matcher)
-	}
-
-	return sil, nil
-}
-
-func (api *API) postSilencesHandler(params silence_ops.PostSilencesParams) middleware.Responder {
-	logger := api.requestLogger(params.HTTPRequest)
-
-	sil, err := postableSilenceToProto(params.Silence)
-	if err != nil {
-		level.Error(logger).Log("msg", "Failed to marshal silence to proto", "err", err)
-		return silence_ops.NewPostSilencesBadRequest().WithPayload(
-			fmt.Sprintf("failed to convert API silence to internal silence: %v", err.Error()),
-		)
-	}
-
-	if sil.StartsAt.After(sil.EndsAt) || sil.StartsAt.Equal(sil.EndsAt) {
-		msg := "Failed to create silence: start time must be before end time"
-		level.Error(logger).Log("msg", msg, "starts_at", sil.StartsAt, "ends_at", sil.EndsAt)
-		return silence_ops.NewPostSilencesBadRequest().WithPayload(msg)
-	}
-
-	if sil.EndsAt.Before(time.Now()) {
-		msg := "Failed to create silence: end time can't be in the past"
-		level.Error(logger).Log("msg", msg, "ends_at", sil.EndsAt)
-		return silence_ops.NewPostSilencesBadRequest().WithPayload(msg)
-	}
-
-	sid, err := api.silences.Set(sil)
-	if err != nil {
-		level.Error(logger).Log("msg", "Failed to create silence", "err", err)
-		if err == silence.ErrNotFound {
-			return silence_ops.NewPostSilencesNotFound().WithPayload(err.Error())
-		}
-		return silence_ops.NewPostSilencesBadRequest().WithPayload(err.Error())
-	}
-
-	return silence_ops.NewPostSilencesOK().WithPayload(&silence_ops.PostSilencesOKBody{
-		SilenceID: sid,
-	})
-}
-
-func postableSilenceToProto(s *open_api_models.PostableSilence) (*silencepb.Silence, error) {
-	sil := &silencepb.Silence{
-		Id:        s.ID,
-		StartsAt:  time.Time(*s.StartsAt),
-		EndsAt:    time.Time(*s.EndsAt),
-		Comment:   *s.Comment,
-		CreatedBy: *s.CreatedBy,
-	}
-	for _, m := range s.Matchers {
-		matcher := &silencepb.Matcher{
-			Name:    *m.Name,
-			Pattern: *m.Value,
-			Type:    silencepb.Matcher_EQUAL,
-		}
-		if *m.IsRegex {
-			matcher.Type = silencepb.Matcher_REGEXP
-		}
-		sil.Matchers = append(sil.Matchers, matcher)
-	}
-	return sil, nil
-}
-
-func parseFilter(filter []string) ([]*labels.Matcher, error) {
-	matchers := make([]*labels.Matcher, 0, len(filter))
-	for _, matcherString := range filter {
-		matcher, err := labels.ParseMatcher(matcherString)
-		if err != nil {
-			return nil, err
-		}
-
-		matchers = append(matchers, matcher)
-	}
-	return matchers, nil
-}
diff --git a/api/v2/api_test.go b/api/v2/api_test.go
deleted file mode 100644
index 4cb4b74..0000000
--- a/api/v2/api_test.go
+++ /dev/null
@@ -1,173 +0,0 @@
-// Copyright 2019 Prometheus Team
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package v2
-
-import (
-	"strconv"
-	"testing"
-	"time"
-
-	"github.com/go-openapi/strfmt"
-	"github.com/prometheus/common/model"
-	"github.com/stretchr/testify/require"
-
-	open_api_models "github.com/prometheus/alertmanager/api/v2/models"
-	general_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/general"
-	"github.com/prometheus/alertmanager/config"
-	"github.com/prometheus/alertmanager/types"
-)
-
-// If api.peers == nil, Alertmanager cluster feature is disabled. Make sure to
-// not try to access properties of peer, which would trigger a nil pointer
-// dereference.
-func TestGetStatusHandlerWithNilPeer(t *testing.T) {
-	api := API{
-		uptime:             time.Now(),
-		peer:               nil,
-		alertmanagerConfig: &config.Config{},
-	}
-
-	// Test ensures this method call does not panic.
-	status := api.getStatusHandler(general_ops.GetStatusParams{}).(*general_ops.GetStatusOK)
-
-	c := status.Payload.Cluster
-
-	if c == nil || c.Status == nil {
-		t.Fatal("expected cluster status not to be nil, violating the openapi specification")
-	}
-
-	if c.Peers == nil {
-		t.Fatal("expected cluster peers to be not nil when api.peer is nil, violating the openapi specification")
-	}
-	if len(c.Peers) != 0 {
-		t.Fatal("expected cluster peers to be empty when api.peer is nil, violating the openapi specification")
-	}
-
-	if c.Name != "" {
-		t.Fatal("expected cluster name to be empty, violating the openapi specification")
-	}
-}
-
-func assertEqualStrings(t *testing.T, expected string, actual string) {
-	if expected != actual {
-		t.Fatal("expected: ", expected, ", actual: ", actual)
-	}
-}
-
-var (
-	testComment = "comment"
-	createdBy   = "test"
-)
-
-func gettableSilence(id string, state string,
-	updatedAt string, start string, end string,
-) *open_api_models.GettableSilence {
-
-	updAt, err := strfmt.ParseDateTime(updatedAt)
-	if err != nil {
-		panic(err)
-	}
-	strAt, err := strfmt.ParseDateTime(start)
-	if err != nil {
-		panic(err)
-	}
-	endAt, err := strfmt.ParseDateTime(end)
-	if err != nil {
-		panic(err)
-	}
-	return &open_api_models.GettableSilence{
-		Silence: open_api_models.Silence{
-			StartsAt:  &strAt,
-			EndsAt:    &endAt,
-			Comment:   &testComment,
-			CreatedBy: &createdBy,
-		},
-		ID:        &id,
-		UpdatedAt: &updAt,
-		Status: &open_api_models.SilenceStatus{
-			State: &state,
-		},
-	}
-}
-
-func TestGetSilencesHandler(t *testing.T) {
-
-	updateTime := "2019-01-01T12:00:00+00:00"
-	silences := []*open_api_models.GettableSilence{
-		gettableSilence("silence-6-expired", "expired", updateTime,
-			"2019-01-01T12:00:00+00:00", "2019-01-01T11:00:00+00:00"),
-		gettableSilence("silence-1-active", "active", updateTime,
-			"2019-01-01T12:00:00+00:00", "2019-01-01T13:00:00+00:00"),
-		gettableSilence("silence-7-expired", "expired", updateTime,
-			"2019-01-01T12:00:00+00:00", "2019-01-01T10:00:00+00:00"),
-		gettableSilence("silence-5-expired", "expired", updateTime,
-			"2019-01-01T12:00:00+00:00", "2019-01-01T12:00:00+00:00"),
-		gettableSilence("silence-0-active", "active", updateTime,
-			"2019-01-01T12:00:00+00:00", "2019-01-01T12:00:00+00:00"),
-		gettableSilence("silence-4-pending", "pending", updateTime,
-			"2019-01-01T13:00:00+00:00", "2019-01-01T12:00:00+00:00"),
-		gettableSilence("silence-3-pending", "pending", updateTime,
-			"2019-01-01T12:00:00+00:00", "2019-01-01T12:00:00+00:00"),
-		gettableSilence("silence-2-active", "active", updateTime,
-			"2019-01-01T12:00:00+00:00", "2019-01-01T14:00:00+00:00"),
-	}
-	sortSilences(open_api_models.GettableSilences(silences))
-
-	for i, sil := range silences {
-		assertEqualStrings(t, "silence-"+strconv.Itoa(i)+"-"+*sil.Status.State, *sil.ID)
-	}
-}
-
-func convertDateTime(ts time.Time) *strfmt.DateTime {
-	dt := strfmt.DateTime(ts)
-	return &dt
-}
-
-func TestAlertToOpenAPIAlert(t *testing.T) {
-	var (
-		start     = time.Now().Add(-time.Minute)
-		updated   = time.Now()
-		active    = "active"
-		fp        = "0223b772b51c29e1"
-		receivers = []string{"receiver1", "receiver2"}
-
-		alert = &types.Alert{
-			Alert: model.Alert{
-				Labels:   model.LabelSet{"severity": "critical", "alertname": "alert1"},
-				StartsAt: start,
-			},
-			UpdatedAt: updated,
-		}
-	)
-	openAPIAlert := alertToOpenAPIAlert(alert, types.AlertStatus{State: types.AlertStateActive}, receivers)
-	require.Equal(t, &open_api_models.GettableAlert{
-		Annotations: open_api_models.LabelSet{},
-		Alert: open_api_models.Alert{
-			Labels: open_api_models.LabelSet{"severity": "critical", "alertname": "alert1"},
-		},
-		Status: &open_api_models.AlertStatus{
-			State:       &active,
-			InhibitedBy: []string{},
-			SilencedBy:  []string{},
-		},
-		StartsAt:    convertDateTime(start),
-		EndsAt:      convertDateTime(time.Time{}),
-		UpdatedAt:   convertDateTime(updated),
-		Fingerprint: &fp,
-		Receivers: []*open_api_models.Receiver{
-			&open_api_models.Receiver{Name: &receivers[0]},
-			&open_api_models.Receiver{Name: &receivers[1]},
-		},
-	}, openAPIAlert)
-}
diff --git a/api/v2/client/alert/alert_client.go b/api/v2/client/alert/alert_client.go
deleted file mode 100644
index 7d299c4..0000000
--- a/api/v2/client/alert/alert_client.go
+++ /dev/null
@@ -1,114 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// Copyright Prometheus Team
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-package alert
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"fmt"
-
-	"github.com/go-openapi/runtime"
-
-	strfmt "github.com/go-openapi/strfmt"
-)
-
-// New creates a new alert API client.
-func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client {
-	return &Client{transport: transport, formats: formats}
-}
-
-/*
-Client for alert API
-*/
-type Client struct {
-	transport runtime.ClientTransport
-	formats   strfmt.Registry
-}
-
-/*
-GetAlerts Get a list of alerts
-*/
-func (a *Client) GetAlerts(params *GetAlertsParams) (*GetAlertsOK, error) {
-	// TODO: Validate the params before sending
-	if params == nil {
-		params = NewGetAlertsParams()
-	}
-
-	result, err := a.transport.Submit(&runtime.ClientOperation{
-		ID:                 "getAlerts",
-		Method:             "GET",
-		PathPattern:        "/alerts",
-		ProducesMediaTypes: []string{"application/json"},
-		ConsumesMediaTypes: []string{"application/json"},
-		Schemes:            []string{"http"},
-		Params:             params,
-		Reader:             &GetAlertsReader{formats: a.formats},
-		Context:            params.Context,
-		Client:             params.HTTPClient,
-	})
-	if err != nil {
-		return nil, err
-	}
-	success, ok := result.(*GetAlertsOK)
-	if ok {
-		return success, nil
-	}
-	// unexpected success response
-	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
-	msg := fmt.Sprintf("unexpected success response for getAlerts: API contract not enforced by server. Client expected to get an error, but got: %T", result)
-	panic(msg)
-}
-
-/*
-PostAlerts Create new Alerts
-*/
-func (a *Client) PostAlerts(params *PostAlertsParams) (*PostAlertsOK, error) {
-	// TODO: Validate the params before sending
-	if params == nil {
-		params = NewPostAlertsParams()
-	}
-
-	result, err := a.transport.Submit(&runtime.ClientOperation{
-		ID:                 "postAlerts",
-		Method:             "POST",
-		PathPattern:        "/alerts",
-		ProducesMediaTypes: []string{"application/json"},
-		ConsumesMediaTypes: []string{"application/json"},
-		Schemes:            []string{"http"},
-		Params:             params,
-		Reader:             &PostAlertsReader{formats: a.formats},
-		Context:            params.Context,
-		Client:             params.HTTPClient,
-	})
-	if err != nil {
-		return nil, err
-	}
-	success, ok := result.(*PostAlertsOK)
-	if ok {
-		return success, nil
-	}
-	// unexpected success response
-	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
-	msg := fmt.Sprintf("unexpected success response for postAlerts: API contract not enforced by server. Client expected to get an error, but got: %T", result)
-	panic(msg)
-}
-
-// SetTransport changes the transport on the client
-func (a *Client) SetTransport(transport runtime.ClientTransport) {
-	a.transport = transport
-}
diff --git a/api/v2/client/alert/get_alerts_parameters.go b/api/v2/client/alert/get_alerts_parameters.go
deleted file mode 100644
index cba0387..0000000
--- a/api/v2/client/alert/get_alerts_parameters.go
+++ /dev/null
@@ -1,350 +0,0 @@
-// Code generated by go-swagger; DO NOT EDIT.
-
-// Copyright Prometheus Team
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-package alert
-
-// This file was generated by the swagger tool.
-// Editing this file might prove futile when you re-run the swagger generate command
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"github.com/go-openapi/errors"
-	"github.com/go-openapi/runtime"
-	cr "github.com/go-openapi/runtime/client"
-	"github.com/go-openapi/swag"
-
-	strfmt "github.com/go-openapi/strfmt"
-)
-
-// NewGetAlertsParams creates a new GetAlertsParams object
-// with the default values initialized.
-func NewGetAlertsParams() *GetAlertsParams {
-	var (
-		activeDefault      = bool(true)
-		inhibitedDefault   = bool(true)
-		silencedDefault    = bool(true)
-		unprocessedDefault = bool(true)
-	)
-	return &GetAlertsParams{
-		Active:      &activeDefault,
-		Inhibited:   &inhibitedDefault,
-		Silenced:    &silencedDefault,
-		Unprocessed: &unprocessedDefault,
-
-		timeout: cr.DefaultTimeout,
-	}
-}
-
-// NewGetAlertsParamsWithTimeout creates a new GetAlertsParams object
-// with the default values initialized, and the ability to set a timeout on a request
-func NewGetAlertsParamsWithTimeout(timeout time.Duration) *GetAlertsParams {
-	var (
-		activeDefault      = bool(true)
-		inhibitedDefault   = bool(true)
-		silencedDefault    = bool(true)
-		unprocessedDefault = bool(true)
-	)
-	return &GetAlertsParams{
-		Active:      &activeDefault,
-		Inhibited:   &inhibitedDefault,
-		Silenced:    &silencedDefault,
-		Unprocessed: &unprocessedDefault,
-
-		timeout: timeout,
-	}
-}
-
-// NewGetAlertsParamsWithContext creates a new GetAlertsParams object
-// with the default values initialized, and the ability to set a context for a request
-func NewGetAlertsParamsWithContext(ctx context.Context) *GetAlertsParams {
-	var (
-		activeDefault      = bool(true)
-		inhibitedDefault   = bool(true)
-		silencedDefault    = bool(true)
-		unprocessedDefault = bool(true)
-	)
-	return &GetAlertsParams{
-		Active:      &activeDefault,
-		Inhibited:   &inhibitedDefault,
-		Silenced:    &silencedDefault,
-		Unprocessed: &unprocessedDefault,
-
-		Context: ctx,
-	}
-}
-
-// NewGetAlertsParamsWithHTTPClient creates a new GetAlertsParams object
-// with the default values initialized, and the ability to set a custom HTTPClient for a request
-func NewGetAlertsParamsWithHTTPClient(client *http.Client) *GetAlertsParams {
-	var (
-		activeDefault      = bool(true)
-		inhibitedDefault   = bool(true)
-		silencedDefault    = bool(true)
-		unprocessedDefault = bool(true)
-	)
-	return &GetAlertsParams{
-		Active:      &activeDefault,
-		Inhibited:   &inhibitedDefault,
-		Silenced:    &silencedDefault,
-		Unprocessed: &unprocessedDefault,
-		HTTPClient:  client,
-	}
-}
-
-/*GetAlertsParams contains all the parameters to send to the API endpoint
-for the get alerts operation typically these are written to a http.Request
-*/
-type GetAlertsParams struct {
-
-	/*Active
-	  Show active alerts
-
-	*/
-	Active *bool
-	/*Filter
-	  A list of matchers to filter alerts by
-
-	*/
-	Filter []string
-	/*Inhibited
-	  Show inhibited alerts
-
-	*/
-	Inhibited *bool
-	/*Receiver
-	  A regex matching receivers to filter alerts by
-
-	*/
-	Receiver *string
-	/*Silenced
-	  Show silenced alerts
-
-	*/
-	Silenced *bool
-	/*Unprocessed
-	  Show unprocessed alerts
-
-	*/
-	Unprocessed *bool
-
-	timeout    time.Duration
-	Context    context.Context
-	HTTPClient *http.Client
-}
-
-// WithTimeout adds the timeout to the get alerts params
-func (o *GetAlertsParams) WithTimeout(timeout time.Duration) *GetAlertsParams {
-	o.SetTimeout(timeout)
-	return o
-}
-
-// SetTimeout adds the timeout to the get alerts params
-func (o *GetAlertsParams) SetTimeout(timeout time.Duration) {
-	o.timeout = timeout
-}
-
-// WithContext adds the context to the get alerts params
-func (o *GetAlertsParams) WithContext(ctx context.Context) *GetAlertsParams {
-	o.SetContext(ctx)
-	return o
-}
-
-// SetContext adds the context to the get alerts params
-func (o *GetAlertsParams) SetContext(ctx context.Context) {
-	o.Context = ctx
-}
-
-// WithHTTPClient adds the HTTPClient to the get alerts params
-func (o *GetAlertsParams) WithHTTPClient(client *http.Client) *GetAlertsParams {
-	o.SetHTTPClient(client)
-	return o
-}
-
-// SetHTTPClient adds the HTTPClient to the get alerts params
-func (o *GetAlertsParams) SetHTTPClient(client *http.Client) {
-	o.HTTPClient = client
-}
-
-// WithActive adds the active to the get alerts params
-func (o *GetAlertsParams) WithActive(active *bool) *GetAlertsParams {
-	o.SetActive(active)
-	return o
-}
-
-// SetActive adds the active to the get alerts params
-func (o *GetAlertsParams) SetActive(active *bool) {
-	o.Active = active
-}
-
-// WithFilter adds the filter to the get alerts params
-func (o *GetAlertsParams) WithFilter(filter []string) *GetAlertsParams {
-	o.SetFilter(filter)
-	return o
-}
-
-// SetFilter adds the filter to the get alerts params
-func (o *GetAlertsParams) SetFilter(filter []string) {
-	o.Filter = filter
-}
-
-// WithInhibited adds the inhibited to the get alerts params
-func (o *GetAlertsParams) WithInhibited(inhibited *bool) *GetAlertsParams {
-	o.SetInhibited(inhibited)
-	return o
-}
-
-// SetInhibited adds the inhibited to the get alerts params
-func (o *GetAlertsParams) SetInhibited(inhibited *bool) {
-	o.Inhibited = inhibited
-}
-
-// WithReceiver adds the receiver to the get alerts params
-func (o *GetAlertsParams) WithReceiver(receiver *string) *GetAlertsParams {
-	o.SetReceiver(receiver)
-	return o
-}
-
-// SetReceiver adds the receiver to the get alerts params
-func (o *GetAlertsParams) SetReceiver(receiver *string) {
-	o.Receiver = receiver
-}
-
-// WithSilenced adds the silenced to the get alerts params
-func (o *GetAlertsParams) WithSilenced(silenced *bool) *GetAlertsParams {
-	o.SetSilenced(silenced)
-	return o
-}
-
-// SetSilenced adds the silenced to the get alerts params
-func (o *GetAlertsParams) SetSilenced(silenced *bool) {
-	o.Silenced = silenced
-}
-
-// WithUnprocessed adds the unprocessed to the get alerts params
-func (o *GetAlertsParams) WithUnprocessed(unprocessed *bool) *GetAlertsParams {
-	o.SetUnprocessed(unprocessed)
-	return o
-}
-
-// SetUnprocessed adds the unprocessed to the get alerts params
-func (o *GetAlertsParams) SetUnprocessed(unprocessed *bool) {
-	o.Unprocessed = unprocessed
-}
-
-// WriteToRequest writes these params to a swagger request
-func (o *GetAlertsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error {
-
-	if err := r.SetTimeout(o.timeout); err != nil {
-		return err
-	}
-	var res []error
-
-	if o.Active != nil {
-
-		// query param active
-		var qrActive bool
-		if o.Active != nil {
-			qrActive = *o.Active
-		}
-		qActive := swag.FormatBool(qrActive)
-		if qActive != "" {
-			if err := r.SetQueryParam("active", qActive); err != nil {
-				return err
-			}
-		}
-
-	}
-
-	valuesFilter := o.Filter
-
-	joinedFilter := swag.JoinByFormat(valuesFilter, "multi")
-	// query array param filter
-	if err := r.SetQueryParam("filter", joinedFilter...); err != nil {
-		return err
-	}
-
-	if o.Inhibited != nil {
-
-		// query param inhibited
-		var qrInhibited bool
-		if o.Inhibited != nil {
-			qrInhibited = *o.Inhibited
-		}
-		qInhibited := swag.FormatBool(qrInhibited)
-		if qInhibited != "" {
-			if err := r.SetQueryParam("inhibited", qInhibited); err != nil {
-				return err
-			}
-		}
-
-	}
-
-	if o.Receiver != nil {
-
-		// query param receiver
-		var qrReceiver string