vendor/git.autistici.org/ai3/replds/http.go → vendor/git.autistici.org/ai3/tools/replds/http.go

@@ -84,7 +84,7 @@ func (s *HTTPServer) Handler() http.Handler {
 	return h
 }
 
-func nodes2str(nodes []Node) string {
+func nodes2str(nodes []*Node) string {
 	var tmp []string
 	for _, node := range nodes {
 		tmp = append(tmp, fmt.Sprintf("%s@%d", node.Path, node.Timestamp.Unix()))

vendor/git.autistici.org/ai3/tools/replds/renovate.json

+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:base"
+  ]
+}

vendor/git.autistici.org/ai3/replds/server.go → vendor/git.autistici.org/ai3/tools/replds/server.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"log"
+	"math/rand"
 	"strings"
 	"sync"
 	"time"
@@ -21,7 +22,7 @@ var (
 	pollPeriod = 120 * time.Second
 
 	// Timeout for InternalGetNodes requests.
-	getNodesTimeout = 20 * time.Second
+	getNodesTimeout = 120 * time.Second
 )
 
 // Node is an annotated path/value entry.
@@ -34,6 +35,15 @@ type Node struct {
 	Deleted bool `json:"deleted,omitempty"`
 }
 
+func (n *Node) Copy() *Node {
+	return &Node{
+		Path:      n.Path,
+		Value:     n.Value,
+		Timestamp: n.Timestamp,
+		Deleted:   n.Deleted,
+	}
+}
+
 func (n *Node) withoutValue() *Node {
 	return &Node{
 		Path:      n.Path,
@@ -42,29 +52,29 @@ func (n *Node) withoutValue() *Node {
 	}
 }
 
-func (n *Node) metadataOnly() Node {
-	return Node{
+func (n *Node) metadataOnly() *Node {
+	return &Node{
 		Path:      n.Path,
 		Timestamp: n.Timestamp,
 	}
 }
 
 type internalGetNodesRequest struct {
-	Nodes []Node `json:"nodes"`
+	Nodes []*Node `json:"nodes"`
 }
 
 type internalGetNodesResponse struct {
-	Nodes   []Node `json:"nodes"`
-	Partial bool   `json:"partial,omitempty"`
+	Nodes   []*Node `json:"nodes"`
+	Partial bool    `json:"partial,omitempty"`
 }
 
 type internalUpdateNodesRequest struct {
-	Nodes []Node `json:"nodes"`
+	Nodes []*Node `json:"nodes"`
 }
 
 // SetNodesRequest is the request type for the SetNodes method.
 type SetNodesRequest struct {
-	Nodes []Node `json:"nodes"`
+	Nodes []*Node `json:"nodes"`
 }
 
 // SetNodesResponse is the response returned by the SetNodes method.
@@ -76,17 +86,18 @@ type SetNodesResponse struct {
 var errTooOld = errors.New("a more recent value exists for this key")
 
 type storage interface {
-	getAllNodes() []Node
+	getAllNodes() []*Node
 	getNodeValue(string) ([]byte, error)
-	setNode(Node) error
+	setNode(*Node) error
 }
 
 // Server for the replicated filesync.
 type Server struct {
-	peers   []string
-	network *network
-	storage storage
-	logger  *log.Logger
+	peers    []string
+	network  *network
+	storage  storage
+	logger   *log.Logger
+	readonly bool
 
 	wg    sync.WaitGroup
 	stop  chan bool
@@ -103,7 +114,7 @@ func stripTrailingSlash(peers []string) []string {
 }
 
 // NewServer creates a new Server with the given peers and backends.
-func NewServer(peers []string, dir string, tlsConfig *clientutil.TLSClientConfig) (*Server, error) {
+func NewServer(peers []string, dir string, tlsConfig *clientutil.TLSClientConfig, readonly bool) (*Server, error) {
 	peers = stripTrailingSlash(peers)
 
 	network, err := newNetwork(peers, tlsConfig)
@@ -112,26 +123,44 @@ func NewServer(peers []string, dir string, tlsConfig *clientutil.TLSClientConfig
 	}
 
 	s := &Server{
-		peers:   peers,
-		network: network,
-		storage: newFS(dir),
-		stop:    make(chan bool),
-		nodes:   make(map[string]*Node),
+		peers:    peers,
+		network:  network,
+		storage:  newFS(dir),
+		stop:     make(chan bool),
+		nodes:    make(map[string]*Node),
+		readonly: readonly,
 	}
 
-	for _, node := range s.storage.getAllNodes() {
-		s.nodes[node.Path] = &node
-	}
-	if len(s.nodes) > 0 {
-		log.Printf("found %d entries in %s", len(s.nodes), dir)
+	// Do not scan the local filesystem at startup on readonly
+	// instances, downloading everything is safer as we do not
+	// risk injecting stale data.
+	if !readonly {
+		for _, node := range s.storage.getAllNodes() {
+			s.nodes[node.Path] = node
+		}
+		if len(s.nodes) > 0 {
+			log.Printf("found %d entries in %s", len(s.nodes), dir)
+		}
 	}
 
-	for _, peer := range peers {
+	// The background workers are different if the instance is
+	// readonly: normally we run a synchronization worker for each
+	// peer, while in the readonly case we periodically poll a
+	// different random peer.
+	if readonly {
 		s.wg.Add(1)
-		go func(peer string) {
-			s.pollThread(peer)
+		go func() {
+			s.pollRandomPeerThread()
 			s.wg.Done()
-		}(peer)
+		}()
+	} else {
+		for _, peer := range peers {
+			s.wg.Add(1)
+			go func(peer string) {
+				s.pollThread(peer)
+				s.wg.Done()
+			}(peer)
+		}
 	}
 
 	return s, nil
@@ -156,7 +185,7 @@ func (s *Server) log(fmt string, args ...interface{}) {
 // Update one or more nodes as a "transaction": if one update fails,
 // the rest are aborted (but previous commits are not reverted, yet).
 // Will ping peers with the data when updatePeers is true.
-func (s *Server) doSetNodes(ctx context.Context, nodes []Node, updatePeers bool) (*SetNodesResponse, error) {
+func (s *Server) doSetNodes(ctx context.Context, nodes []*Node, updatePeers bool) (*SetNodesResponse, error) {
 	// Update local state.
 	for _, node := range nodes {
 		cur, ok := s.nodes[node.Path]
@@ -185,7 +214,9 @@ func (s *Server) doSetNodes(ctx context.Context, nodes []Node, updatePeers bool)
 
 	var res SetNodesResponse
 	if updatePeers {
-		// Ping remote nodes with updated state.
+		// Ping remote nodes with the updated state. This
+		// reduces the latency of update propagation (we don't
+		// have to wait until the peers poll us).
 		res.HostsOk = 1
 		for _, peer := range s.peers {
 			err := s.network.Client(peer).internalUpdateNodes(ctx, &internalUpdateNodesRequest{
@@ -216,13 +247,13 @@ func (s *Server) internalUpdateNodes(ctx context.Context, req *internalUpdateNod
 	return err
 }
 
-func (s *Server) getNodeWithValue(node *Node) (out Node, err error) {
-	out = *node
+func (s *Server) getNodeWithValue(node *Node) (out *Node, err error) {
+	out = node.Copy()
 	out.Value, err = s.storage.getNodeValue(node.Path)
 	return
 }
 
-func nodeDiff(reqNodes []Node, myNodes map[string]*Node, adder func(*Node) bool) ([]string, bool) {
+func nodeDiff(reqNodes []*Node, myNodes map[string]*Node, adder func(*Node) bool) ([]string, bool) {
 	var missing []string
 	tmp := make(map[string]struct{})
 	for _, reqNode := range reqNodes {
@@ -293,14 +324,8 @@ func (s *Server) internalGetNodes(ctx context.Context, req *internalGetNodesRequ
 	return &resp, nil
 }
 
-func (s *Server) pollThread(peer string) {
-	poll := func() {
-		if err := s.pollPeer(peer); err != nil {
-			s.log("error polling peer %s: %v", peer, err)
-		}
-	}
-
-	poll()
+func (s *Server) backgroundThread(fn func()) {
+	fn()
 
 	tick := time.NewTicker(pollPeriod)
 	defer tick.Stop()
@@ -309,11 +334,32 @@ func (s *Server) pollThread(peer string) {
 		case <-s.stop:
 			return
 		case <-tick.C:
-			poll()
+			fn()
 		}
 	}
 }
 
+func (s *Server) pollThread(peer string) {
+	s.backgroundThread(func() {
+		if err := s.pollPeer(peer); err != nil {
+			s.log("error polling peer %s: %v", peer, err)
+		}
+	})
+}
+
+func (s *Server) pollRandomPeerThread() {
+	s.backgroundThread(func() {
+		if len(s.peers) == 0 {
+			s.log("no peers to poll!")
+			return
+		}
+		peer := s.peers[rand.Intn(len(s.peers))]
+		if err := s.pollPeer(peer); err != nil {
+			s.log("error polling peer %s: %v", peer, err)
+		}
+	})
+}
+
 func (s *Server) pollPeer(peer string) error {
 	for {
 		partial, err := s.pollPeerRequest(peer)
@@ -353,7 +399,7 @@ var (
 	maxTSValue int64
 )
 
-func updateMaxTimestamp(nodes []Node) {
+func updateMaxTimestamp(nodes []*Node) {
 	var max int64
 	for _, node := range nodes {
 		t := node.Timestamp.Unix()
@@ -375,6 +421,9 @@ func (s *Server) pollPeerRequest(peer string) (bool, error) {
 	peerName := stripHTTP(peer)
 	peerRequests.With(prometheus.Labels{"peer": peerName}).Inc()
 
+	// Create a shallow copy of the list of the Nodes we know
+	// about, containing just path/timestamp, to send to the peer
+	// in our GetNodes request.
 	s.mx.Lock()
 	var req internalGetNodesRequest
 	for _, node := range s.nodes {
@@ -399,6 +448,7 @@ func (s *Server) pollPeerRequest(peer string) (bool, error) {
 		return false, nil
 	}
 
+	// Update the internal state with the new data.
 	return resp.Partial, s.internalUpdateNodes(ctx, &internalUpdateNodesRequest{Nodes: resp.Nodes})
 }
 

vendor/github.com/NYTimes/gziphandler/.gitignore

+*.swp

vendor/github.com/NYTimes/gziphandler/.travis.yml

+language: go
+go:
+  - 1.x
+  - tip
+env:
+  - GO111MODULE=on
+install:
+  - go mod download
+script:
+  - go test -race -v

vendor/github.com/NYTimes/gziphandler/CODE_OF_CONDUCT.md

+---
+layout: code-of-conduct
+version: v1.0
+---
+
+This code of conduct outlines our expectations for participants within the **NYTimes/gziphandler** community, as well as steps to reporting unacceptable behavior. We are committed to providing a welcoming and inspiring community for all and expect our code of conduct to be honored. Anyone who violates this code of conduct may be banned from the community.
+
+Our open source community strives to:
+
+* **Be friendly and patient.**
+* **Be welcoming**: We strive to be a community that welcomes and supports people of all backgrounds and identities. This includes, but is not limited to members of any race, ethnicity, culture, national origin, colour, immigration status, social and economic class, educational level, sex, sexual orientation, gender identity and expression, age, size, family status, political belief, religion, and mental and physical ability.
+* **Be considerate**: Your work will be used by other people, and you in turn will depend on the work of others. Any decision you take will affect users and colleagues, and you should take those consequences into account when making decisions. Remember that we're a world-wide community, so you might not be communicating in someone else's primary language.
+* **Be respectful**:  Not all of us will agree all the time, but disagreement is no excuse for poor behavior and poor manners. We might all experience some frustration now and then, but we cannot allow that frustration to turn into a personal attack. It’s important to remember that a community where people feel uncomfortable or threatened is not a productive one.
+* **Be careful in the words that we choose**: we are a community of professionals, and we conduct ourselves professionally. Be kind to others. Do not insult or put down other participants. Harassment and other exclusionary behavior aren't acceptable.
+* **Try to understand why we disagree**: Disagreements, both social and technical, happen all the time. It is important that we resolve disagreements and differing views constructively. Remember that we’re different. The strength of our community comes from its diversity, people from a wide range of backgrounds. Different people have different perspectives on issues. Being unable to understand why someone holds a viewpoint doesn’t mean that they’re wrong. Don’t forget that it is human to err and blaming each other doesn’t get us anywhere. Instead, focus on helping to resolve issues and learning from mistakes.
+
+## Definitions
+
+Harassment includes, but is not limited to:
+
+- Offensive comments related to gender, gender identity and expression, sexual orientation, disability, mental illness, neuro(a)typicality, physical appearance, body size, race, age, regional discrimination, political or religious affiliation
+- Unwelcome comments regarding a person’s lifestyle choices and practices, including those related to food, health, parenting, drugs, and employment
+- Deliberate misgendering. This includes deadnaming or persistently using a pronoun that does not correctly reflect a person's gender identity. You must address people by the name they give you when not addressing them by their username or handle
+- Physical contact and simulated physical contact (eg, textual descriptions like “*hug*” or “*backrub*”) without consent or after a request to stop
+- Threats of violence, both physical and psychological
+- Incitement of violence towards any individual, including encouraging a person to commit suicide or to engage in self-harm
+- Deliberate intimidation
+- Stalking or following
+- Harassing photography or recording, including logging online activity for harassment purposes
+- Sustained disruption of discussion
+- Unwelcome sexual attention, including gratuitous or off-topic sexual images or behaviour
+- Pattern of inappropriate social contact, such as requesting/assuming inappropriate levels of intimacy with others
+- Continued one-on-one communication after requests to cease
+- Deliberate “outing” of any aspect of a person’s identity without their consent except as necessary to protect others from intentional abuse
+- Publication of non-harassing private communication
+
+Our open source community prioritizes marginalized people’s safety over privileged people’s comfort. We will not act on complaints regarding:
+
+- ‘Reverse’ -isms, including ‘reverse racism,’ ‘reverse sexism,’ and ‘cisphobia’
+- Reasonable communication of boundaries, such as “leave me alone,” “go away,” or “I’m not discussing this with you”
+- Refusal to explain or debate social justice concepts
+- Communicating in a ‘tone’ you don’t find congenial
+- Criticizing racist, sexist, cissexist, or otherwise oppressive behavior or assumptions
+
+
+### Diversity Statement
+
+We encourage everyone to participate and are committed to building a community for all. Although we will fail at times, we seek to treat everyone both as fairly and equally as possible. Whenever a participant has made a mistake, we expect them to take responsibility for it. If someone has been harmed or offended, it is our responsibility to listen carefully and respectfully, and do our best to right the wrong.
+
+Although this list cannot be exhaustive, we explicitly honor diversity in age, gender, gender identity or expression, culture, ethnicity, language, national origin, political beliefs, profession, race, religion, sexual orientation, socioeconomic status, and technical ability. We will not tolerate discrimination based on any of the protected
+characteristics above, including participants with disabilities.
+
+### Reporting Issues
+
+If you experience or witness unacceptable behavior—or have any other concerns—please report it by contacting us via **code@nytimes.com**. All reports will be handled with discretion. In your report please include:
+
+- Your contact information.
+- Names (real, nicknames, or pseudonyms) of any individuals involved. If there are additional witnesses, please
+include them as well. Your account of what occurred, and if you believe the incident is ongoing. If there is a publicly available record (e.g. a mailing list archive or a public IRC logger), please include a link.
+- Any additional information that may be helpful.
+
+After filing a report, a representative will contact you personally, review the incident, follow up with any additional questions, and make a decision as to how to respond. If the person who is harassing you is part of the response team, they will recuse themselves from handling your incident. If the complaint originates from a member of the response team, it will be handled by a different member of the response team. We will respect confidentiality requests for the purpose of protecting victims of abuse.
+
+### Attribution & Acknowledgements
+
+We all stand on the shoulders of giants across many open source communities.  We'd like to thank the communities and projects that established code of conducts and diversity statements as our inspiration:
+
+* [Django](https://www.djangoproject.com/conduct/reporting/)
+* [Python](https://www.python.org/community/diversity/)
+* [Ubuntu](http://www.ubuntu.com/about/about-ubuntu/conduct)
+* [Contributor Covenant](http://contributor-covenant.org/)
+* [Geek Feminism](http://geekfeminism.org/about/code-of-conduct/)
+* [Citizen Code of Conduct](http://citizencodeofconduct.org/)
+
+This Code of Conduct was based on https://github.com/todogroup/opencodeofconduct

vendor/github.com/NYTimes/gziphandler/CONTRIBUTING.md

+# Contributing to NYTimes/gziphandler
+
+This is an open source project started by handful of developers at The New York Times and open to the entire Go community.
+
+We really appreciate your help!
+
+## Filing issues
+
+When filing an issue, make sure to answer these five questions:
+
+1. What version of Go are you using (`go version`)?
+2. What operating system and processor architecture are you using?
+3. What did you do?
+4. What did you expect to see?
+5. What did you see instead?
+
+## Contributing code
+
+Before submitting changes, please follow these guidelines:
+
+1. Check the open issues and pull requests for existing discussions.
+2. Open an issue to discuss a new feature.
+3. Write tests.
+4. Make sure code follows the ['Go Code Review Comments'](https://github.com/golang/go/wiki/CodeReviewComments).
+5. Make sure your changes pass `go test`.
+6. Make sure the entire test suite passes locally and on Travis CI.
+7. Open a Pull Request.
+8. [Squash your commits](http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html) after receiving feedback and add a [great commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+
+Unless otherwise noted, the gziphandler source files are distributed under the Apache 2.0-style license found in the LICENSE.md file.

vendor/github.com/NYTimes/gziphandler/LICENSE

+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2016-2017 The New York Times Company
+
+   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.

vendor/github.com/NYTimes/gziphandler/README.md

+Gzip Handler
+============
+
+This is a tiny Go package which wraps HTTP handlers to transparently gzip the
+response body, for clients which support it. Although it's usually simpler to
+leave that to a reverse proxy (like nginx or Varnish), this package is useful
+when that's undesirable.
+
+## Install
+```bash
+go get -u github.com/NYTimes/gziphandler
+```
+
+## Usage
+
+Call `GzipHandler` with any handler (an object which implements the
+`http.Handler` interface), and it'll return a new handler which gzips the
+response. For example:
+
+```go
+package main
+
+import (
+	"io"
+	"net/http"
+	"github.com/NYTimes/gziphandler"
+)
+
+func main() {
+	withoutGz := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/plain")
+		io.WriteString(w, "Hello, World")
+	})
+
+	withGz := gziphandler.GzipHandler(withoutGz)
+
+	http.Handle("/", withGz)
+	http.ListenAndServe("0.0.0.0:8000", nil)
+}
+```
+
+
+## Documentation
+
+The docs can be found at [godoc.org][docs], as usual.
+
+
+## License
+
+[Apache 2.0][license].
+
+
+
+
+[docs]:     https://godoc.org/github.com/NYTimes/gziphandler
+[license]:  https://github.com/NYTimes/gziphandler/blob/master/LICENSE

vendor/github.com/NYTimes/gziphandler/gzip_go18.go

+// +build go1.8
+
+package gziphandler
+
+import "net/http"
+
+// Push initiates an HTTP/2 server push.
+// Push returns ErrNotSupported if the client has disabled push or if push
+// is not supported on the underlying connection.
+func (w *GzipResponseWriter) Push(target string, opts *http.PushOptions) error {
+	pusher, ok := w.ResponseWriter.(http.Pusher)
+	if ok && pusher != nil {
+		return pusher.Push(target, setAcceptEncodingForPushOptions(opts))
+	}
+	return http.ErrNotSupported
+}
+
+// setAcceptEncodingForPushOptions sets "Accept-Encoding" : "gzip" for PushOptions without overriding existing headers.
+func setAcceptEncodingForPushOptions(opts *http.PushOptions) *http.PushOptions {
+
+	if opts == nil {
+		opts = &http.PushOptions{
+			Header: http.Header{
+				acceptEncoding: []string{"gzip"},
+			},
+		}
+		return opts
+	}
+
+	if opts.Header == nil {
+		opts.Header = http.Header{
+			acceptEncoding: []string{"gzip"},
+		}
+		return opts
+	}
+
+	if encoding := opts.Header.Get(acceptEncoding); encoding == "" {
+		opts.Header.Add(acceptEncoding, "gzip")
+		return opts
+	}
+
+	return opts
+}

vendor/github.com/beorn7/perks/quantile/stream.go

@@ -77,15 +77,20 @@ func NewHighBiased(epsilon float64) *Stream {
 // is guaranteed to be within (Quantile±Epsilon).
 //
 // See http://www.cs.rutgers.edu/~muthu/bquant.pdf for time, space, and error properties.
-func NewTargeted(targets map[float64]float64) *Stream {
+func NewTargeted(targetMap map[float64]float64) *Stream {
+	// Convert map to slice to avoid slow iterations on a map.
+	// ƒ is called on the hot path, so converting the map to a slice
+	// beforehand results in significant CPU savings.
+	targets := targetMapToSlice(targetMap)
+
 	ƒ := func(s *stream, r float64) float64 {
 		var m = math.MaxFloat64
 		var f float64
-		for quantile, epsilon := range targets {
-			if quantile*s.n <= r {
-				f = (2 * epsilon * r) / quantile
+		for _, t := range targets {
+			if t.quantile*s.n <= r {
+				f = (2 * t.epsilon * r) / t.quantile
 			} else {
-				f = (2 * epsilon * (s.n - r)) / (1 - quantile)
+				f = (2 * t.epsilon * (s.n - r)) / (1 - t.quantile)
 			}
 			if f < m {
 				m = f
@@ -96,6 +101,25 @@ func NewTargeted(targets map[float64]float64) *Stream {
 	return newStream(ƒ)
 }
 
+type target struct {
+	quantile float64
+	epsilon  float64
+}
+
+func targetMapToSlice(targetMap map[float64]float64) []target {
+	targets := make([]target, 0, len(targetMap))
+
+	for quantile, epsilon := range targetMap {
+		t := target{
+			quantile: quantile,
+			epsilon:  epsilon,
+		}
+		targets = append(targets, t)
+	}
+
+	return targets
+}
+
 // Stream computes quantiles for a stream of float64s. It is not thread-safe by
 // design. Take care when using across multiple goroutines.
 type Stream struct {

vendor/github.com/cenkalti/backoff/v4/.gitignore

+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+
+# IDEs
+.idea/

vendor/github.com/cenkalti/backoff/v4/.travis.yml

+language: go
+go:
+  - 1.13
+  - 1.x
+  - tip
+before_install:
+  - go get github.com/mattn/goveralls
+  - go get golang.org/x/tools/cmd/cover
+script:
+  - $HOME/gopath/bin/goveralls -service=travis-ci

vendor/github.com/cenkalti/backoff/README.md → vendor/github.com/cenkalti/backoff/v4/README.md

@@ -9,7 +9,9 @@ The retries exponentially increase and stop increasing when a certain threshold
 
 ## Usage
 
-See https://godoc.org/github.com/cenkalti/backoff#pkg-examples
+Import path is `github.com/cenkalti/backoff/v4`. Please note the version part at the end.
+
+Use https://pkg.go.dev/github.com/cenkalti/backoff/v4 to view the documentation.
 
 ## Contributing
 
@@ -17,7 +19,7 @@ See https://godoc.org/github.com/cenkalti/backoff#pkg-examples
 * Please don't send a PR without opening an issue and discussing it first.
 * If proposed change is not a common use case, I will probably not accept it.
 
-[godoc]: https://godoc.org/github.com/cenkalti/backoff
+[godoc]: https://pkg.go.dev/github.com/cenkalti/backoff/v4
 [godoc image]: https://godoc.org/github.com/cenkalti/backoff?status.png
 [travis]: https://travis-ci.org/cenkalti/backoff
 [travis image]: https://travis-ci.org/cenkalti/backoff.png?branch=master
@@ -27,4 +29,4 @@ See https://godoc.org/github.com/cenkalti/backoff#pkg-examples
 [google-http-java-client]: https://github.com/google/google-http-java-client/blob/da1aa993e90285ec18579f1553339b00e19b3ab5/google-http-client/src/main/java/com/google/api/client/util/ExponentialBackOff.java
 [exponential backoff wiki]: http://en.wikipedia.org/wiki/Exponential_backoff
 
-[advanced example]: https://godoc.org/github.com/cenkalti/backoff#example_
+[advanced example]: https://pkg.go.dev/github.com/cenkalti/backoff/v4?tab=doc#pkg-examples

vendor/github.com/cenkalti/backoff/context.go → vendor/github.com/cenkalti/backoff/v4/context.go

@@ -7,7 +7,7 @@ import (
 
 // BackOffContext is a backoff policy that stops retrying after the context
 // is canceled.
-type BackOffContext interface {
+type BackOffContext interface { // nolint: golint
 	BackOff
 	Context() context.Context
 }
@@ -20,7 +20,7 @@ type backOffContext struct {
 // WithContext returns a BackOffContext with context ctx
 //
 // ctx must not be nil
-func WithContext(b BackOff, ctx context.Context) BackOffContext {
+func WithContext(b BackOff, ctx context.Context) BackOffContext { // nolint: golint
 	if ctx == nil {
 		panic("nil context")
 	}
@@ -38,11 +38,14 @@ func WithContext(b BackOff, ctx context.Context) BackOffContext {
 	}
 }
 
-func ensureContext(b BackOff) BackOffContext {
+func getContext(b BackOff) context.Context {
 	if cb, ok := b.(BackOffContext); ok {
-		return cb
+		return cb.Context()
 	}
-	return WithContext(b, context.Background())
+	if tb, ok := b.(*backOffTries); ok {
+		return getContext(tb.delegate)
+	}
+	return context.Background()
 }
 
 func (b *backOffContext) Context() context.Context {
@@ -51,7 +54,7 @@ func (b *backOffContext) Context() context.Context {
 
 func (b *backOffContext) NextBackOff() time.Duration {
 	select {
-	case <-b.Context().Done():
+	case <-b.ctx.Done():
 		return Stop
 	default:
 		return b.BackOff.NextBackOff()

vendor/github.com/cenkalti/backoff/exponential.go → vendor/github.com/cenkalti/backoff/v4/exponential.go

@@ -56,14 +56,14 @@ type ExponentialBackOff struct {
 	RandomizationFactor float64
 	Multiplier          float64
 	MaxInterval         time.Duration
-	// After MaxElapsedTime the ExponentialBackOff stops.
+	// After MaxElapsedTime the ExponentialBackOff returns Stop.
 	// It never stops if MaxElapsedTime == 0.
 	MaxElapsedTime time.Duration
+	Stop           time.Duration
 	Clock          Clock
 
 	currentInterval time.Duration
 	startTime       time.Time
-	random          *rand.Rand
 }
 
 // Clock is an interface that returns current time for BackOff.
@@ -88,8 +88,8 @@ func NewExponentialBackOff() *ExponentialBackOff {
 		Multiplier:          DefaultMultiplier,
 		MaxInterval:         DefaultMaxInterval,
 		MaxElapsedTime:      DefaultMaxElapsedTime,
+		Stop:                Stop,
 		Clock:               SystemClock,
-		random:              rand.New(rand.NewSource(time.Now().UnixNano())),
 	}
 	b.Reset()
 	return b
@@ -105,23 +105,23 @@ func (t systemClock) Now() time.Time {
 var SystemClock = systemClock{}
 
 // Reset the interval back to the initial retry interval and restarts the timer.
+// Reset must be called before using b.
 func (b *ExponentialBackOff) Reset() {
 	b.currentInterval = b.InitialInterval
 	b.startTime = b.Clock.Now()
 }
 
 // NextBackOff calculates the next backoff interval using the formula:
-// 	Randomized interval = RetryInterval +/- (RandomizationFactor * RetryInterval)
+// 	Randomized interval = RetryInterval * (1 ± RandomizationFactor)
 func (b *ExponentialBackOff) NextBackOff() time.Duration {
 	// Make sure we have not gone over the maximum elapsed time.
-	if b.MaxElapsedTime != 0 && b.GetElapsedTime() > b.MaxElapsedTime {
-		return Stop
+	elapsed := b.GetElapsedTime()
+	next := getRandomValueFromInterval(b.RandomizationFactor, rand.Float64(), b.currentInterval)
+	b.incrementCurrentInterval()
+	if b.MaxElapsedTime != 0 && elapsed+next > b.MaxElapsedTime {
+		return b.Stop
 	}
-	defer b.incrementCurrentInterval()
-	if b.random == nil {
-		b.random = rand.New(rand.NewSource(time.Now().UnixNano()))
-	}
-	return getRandomValueFromInterval(b.RandomizationFactor, b.random.Float64(), b.currentInterval)
+	return next
 }
 
 // GetElapsedTime returns the elapsed time since an ExponentialBackOff instance
@@ -145,8 +145,11 @@ func (b *ExponentialBackOff) incrementCurrentInterval() {
 }
 
 // Returns a random value from the following interval:
-// 	[randomizationFactor * currentInterval, randomizationFactor * currentInterval].
+// 	[currentInterval - randomizationFactor * currentInterval, currentInterval + randomizationFactor * currentInterval].
 func getRandomValueFromInterval(randomizationFactor, random float64, currentInterval time.Duration) time.Duration {
+	if randomizationFactor == 0 {
+		return currentInterval // make sure no randomness is used when randomizationFactor is 0.
+	}
 	var delta = randomizationFactor * float64(currentInterval)
 	var minInterval = float64(currentInterval) - delta
 	var maxInterval = float64(currentInterval) + delta

vendor/github.com/cenkalti/backoff/retry.go → vendor/github.com/cenkalti/backoff/v4/retry.go

 package backoff
 
-import "time"
+import (
+	"errors"
+	"time"
+)
 
 // An Operation is executing by Retry() or RetryNotify().
 // The operation will be retried using a backoff policy if it returns an error.
@@ -21,15 +24,31 @@ type Notify func(error, time.Duration)
 //
 // Retry sleeps the goroutine for the duration returned by BackOff after a
 // failed operation returns.
-func Retry(o Operation, b BackOff) error { return RetryNotify(o, b, nil) }
+func Retry(o Operation, b BackOff) error {
+	return RetryNotify(o, b, nil)
+}
 
 // RetryNotify calls notify function with the error and wait duration
 // for each failed attempt before sleep.
 func RetryNotify(operation Operation, b BackOff, notify Notify) error {
+	return RetryNotifyWithTimer(operation, b, notify, nil)
+}
+
+// RetryNotifyWithTimer calls notify function with the error and wait duration using the given Timer
+// for each failed attempt before sleep.
+// A default timer that uses system timer is used when nil is passed.
+func RetryNotifyWithTimer(operation Operation, b BackOff, notify Notify, t Timer) error {
 	var err error
 	var next time.Duration
+	if t == nil {
+		t = &defaultTimer{}
+	}
+
+	defer func() {
+		t.Stop()
+	}()
 
-	cb := ensureContext(b)
+	ctx := getContext(b)
 
 	b.Reset()
 	for {
@@ -37,11 +56,16 @@ func RetryNotify(operation Operation, b BackOff, notify Notify) error {
 			return nil
 		}
 
-		if permanent, ok := err.(*PermanentError); ok {
+		var permanent *PermanentError
+		if errors.As(err, &permanent) {
 			return permanent.Err
 		}
 
 		if next = b.NextBackOff(); next == Stop {
+			if cerr := ctx.Err(); cerr != nil {
+				return cerr
+			}
+
 			return err
 		}
 
@@ -49,13 +73,12 @@ func RetryNotify(operation Operation, b BackOff, notify Notify) error {
 			notify(err, next)
 		}
 
-		t := time.NewTimer(next)
+		t.Start(next)
 
 		select {
-		case <-cb.Context().Done():
-			t.Stop()
-			return err
-		case <-t.C:
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-t.C():
 		}
 	}
 }
@@ -69,8 +92,20 @@ func (e *PermanentError) Error() string {
 	return e.Err.Error()
 }
 
+func (e *PermanentError) Unwrap() error {
+	return e.Err
+}
+
+func (e *PermanentError) Is(target error) bool {
+	_, ok := target.(*PermanentError)
+	return ok
+}
+
 // Permanent wraps the given err in a *PermanentError.
-func Permanent(err error) *PermanentError {
+func Permanent(err error) error {
+	if err == nil {
+		return nil
+	}
 	return &PermanentError{
 		Err: err,
 	}