+
+Notes:
+
+1. Large messages are fragmented in [Chrome's new WebSocket implementation](http://www.ietf.org/mail-archive/web/hybi/current/msg10503.html).
+2. The application can get the type of a received data message by implementing
+ a [Codec marshal](http://godoc.org/golang.org/x/net/websocket#Codec.Marshal)
+ function.
+3. The go.net io.Reader and io.Writer operate across WebSocket frame boundaries.
+ Read returns when the input buffer is full or a frame boundary is
+ encountered. Each call to Write sends a single frame message. The Gorilla
+ io.Reader and io.WriteCloser operate on a single WebSocket message.
+
diff --git a/vendor/github.com/gorilla/websocket/client.go b/vendor/github.com/gorilla/websocket/client.go
new file mode 100644
index 0000000000000..962c06a391c23
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/client.go
@@ -0,0 +1,395 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bytes"
+ "context"
+ "crypto/tls"
+ "errors"
+ "io"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "net/http/httptrace"
+ "net/url"
+ "strings"
+ "time"
+)
+
+// ErrBadHandshake is returned when the server response to opening handshake is
+// invalid.
+var ErrBadHandshake = errors.New("websocket: bad handshake")
+
+var errInvalidCompression = errors.New("websocket: invalid compression negotiation")
+
+// NewClient creates a new client connection using the given net connection.
+// The URL u specifies the host and request URI. Use requestHeader to specify
+// the origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies
+// (Cookie). Use the response.Header to get the selected subprotocol
+// (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
+//
+// If the WebSocket handshake fails, ErrBadHandshake is returned along with a
+// non-nil *http.Response so that callers can handle redirects, authentication,
+// etc.
+//
+// Deprecated: Use Dialer instead.
+func NewClient(netConn net.Conn, u *url.URL, requestHeader http.Header, readBufSize, writeBufSize int) (c *Conn, response *http.Response, err error) {
+ d := Dialer{
+ ReadBufferSize: readBufSize,
+ WriteBufferSize: writeBufSize,
+ NetDial: func(net, addr string) (net.Conn, error) {
+ return netConn, nil
+ },
+ }
+ return d.Dial(u.String(), requestHeader)
+}
+
+// A Dialer contains options for connecting to WebSocket server.
+type Dialer struct {
+ // NetDial specifies the dial function for creating TCP connections. If
+ // NetDial is nil, net.Dial is used.
+ NetDial func(network, addr string) (net.Conn, error)
+
+ // NetDialContext specifies the dial function for creating TCP connections. If
+ // NetDialContext is nil, net.DialContext is used.
+ NetDialContext func(ctx context.Context, network, addr string) (net.Conn, error)
+
+ // Proxy specifies a function to return a proxy for a given
+ // Request. If the function returns a non-nil error, the
+ // request is aborted with the provided error.
+ // If Proxy is nil or returns a nil *URL, no proxy is used.
+ Proxy func(*http.Request) (*url.URL, error)
+
+ // TLSClientConfig specifies the TLS configuration to use with tls.Client.
+ // If nil, the default configuration is used.
+ TLSClientConfig *tls.Config
+
+ // HandshakeTimeout specifies the duration for the handshake to complete.
+ HandshakeTimeout time.Duration
+
+ // ReadBufferSize and WriteBufferSize specify I/O buffer sizes in bytes. If a buffer
+ // size is zero, then a useful default size is used. The I/O buffer sizes
+ // do not limit the size of the messages that can be sent or received.
+ ReadBufferSize, WriteBufferSize int
+
+ // WriteBufferPool is a pool of buffers for write operations. If the value
+ // is not set, then write buffers are allocated to the connection for the
+ // lifetime of the connection.
+ //
+ // A pool is most useful when the application has a modest volume of writes
+ // across a large number of connections.
+ //
+ // Applications should use a single pool for each unique value of
+ // WriteBufferSize.
+ WriteBufferPool BufferPool
+
+ // Subprotocols specifies the client's requested subprotocols.
+ Subprotocols []string
+
+ // EnableCompression specifies if the client should attempt to negotiate
+ // per message compression (RFC 7692). Setting this value to true does not
+ // guarantee that compression will be supported. Currently only "no context
+ // takeover" modes are supported.
+ EnableCompression bool
+
+ // Jar specifies the cookie jar.
+ // If Jar is nil, cookies are not sent in requests and ignored
+ // in responses.
+ Jar http.CookieJar
+}
+
+// Dial creates a new client connection by calling DialContext with a background context.
+func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (*Conn, *http.Response, error) {
+ return d.DialContext(context.Background(), urlStr, requestHeader)
+}
+
+var errMalformedURL = errors.New("malformed ws or wss URL")
+
+func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
+ hostPort = u.Host
+ hostNoPort = u.Host
+ if i := strings.LastIndex(u.Host, ":"); i > strings.LastIndex(u.Host, "]") {
+ hostNoPort = hostNoPort[:i]
+ } else {
+ switch u.Scheme {
+ case "wss":
+ hostPort += ":443"
+ case "https":
+ hostPort += ":443"
+ default:
+ hostPort += ":80"
+ }
+ }
+ return hostPort, hostNoPort
+}
+
+// DefaultDialer is a dialer with all fields set to the default values.
+var DefaultDialer = &Dialer{
+ Proxy: http.ProxyFromEnvironment,
+ HandshakeTimeout: 45 * time.Second,
+}
+
+// nilDialer is dialer to use when receiver is nil.
+var nilDialer = *DefaultDialer
+
+// DialContext creates a new client connection. Use requestHeader to specify the
+// origin (Origin), subprotocols (Sec-WebSocket-Protocol) and cookies (Cookie).
+// Use the response.Header to get the selected subprotocol
+// (Sec-WebSocket-Protocol) and cookies (Set-Cookie).
+//
+// The context will be used in the request and in the Dialer.
+//
+// If the WebSocket handshake fails, ErrBadHandshake is returned along with a
+// non-nil *http.Response so that callers can handle redirects, authentication,
+// etcetera. The response body may not contain the entire response and does not
+// need to be closed by the application.
+func (d *Dialer) DialContext(ctx context.Context, urlStr string, requestHeader http.Header) (*Conn, *http.Response, error) {
+ if d == nil {
+ d = &nilDialer
+ }
+
+ challengeKey, err := generateChallengeKey()
+ if err != nil {
+ return nil, nil, err
+ }
+
+ u, err := url.Parse(urlStr)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ switch u.Scheme {
+ case "ws":
+ u.Scheme = "http"
+ case "wss":
+ u.Scheme = "https"
+ default:
+ return nil, nil, errMalformedURL
+ }
+
+ if u.User != nil {
+ // User name and password are not allowed in websocket URIs.
+ return nil, nil, errMalformedURL
+ }
+
+ req := &http.Request{
+ Method: "GET",
+ URL: u,
+ Proto: "HTTP/1.1",
+ ProtoMajor: 1,
+ ProtoMinor: 1,
+ Header: make(http.Header),
+ Host: u.Host,
+ }
+ req = req.WithContext(ctx)
+
+ // Set the cookies present in the cookie jar of the dialer
+ if d.Jar != nil {
+ for _, cookie := range d.Jar.Cookies(u) {
+ req.AddCookie(cookie)
+ }
+ }
+
+ // Set the request headers using the capitalization for names and values in
+ // RFC examples. Although the capitalization shouldn't matter, there are
+ // servers that depend on it. The Header.Set method is not used because the
+ // method canonicalizes the header names.
+ req.Header["Upgrade"] = []string{"websocket"}
+ req.Header["Connection"] = []string{"Upgrade"}
+ req.Header["Sec-WebSocket-Key"] = []string{challengeKey}
+ req.Header["Sec-WebSocket-Version"] = []string{"13"}
+ if len(d.Subprotocols) > 0 {
+ req.Header["Sec-WebSocket-Protocol"] = []string{strings.Join(d.Subprotocols, ", ")}
+ }
+ for k, vs := range requestHeader {
+ switch {
+ case k == "Host":
+ if len(vs) > 0 {
+ req.Host = vs[0]
+ }
+ case k == "Upgrade" ||
+ k == "Connection" ||
+ k == "Sec-Websocket-Key" ||
+ k == "Sec-Websocket-Version" ||
+ k == "Sec-Websocket-Extensions" ||
+ (k == "Sec-Websocket-Protocol" && len(d.Subprotocols) > 0):
+ return nil, nil, errors.New("websocket: duplicate header not allowed: " + k)
+ case k == "Sec-Websocket-Protocol":
+ req.Header["Sec-WebSocket-Protocol"] = vs
+ default:
+ req.Header[k] = vs
+ }
+ }
+
+ if d.EnableCompression {
+ req.Header["Sec-WebSocket-Extensions"] = []string{"permessage-deflate; server_no_context_takeover; client_no_context_takeover"}
+ }
+
+ if d.HandshakeTimeout != 0 {
+ var cancel func()
+ ctx, cancel = context.WithTimeout(ctx, d.HandshakeTimeout)
+ defer cancel()
+ }
+
+ // Get network dial function.
+ var netDial func(network, add string) (net.Conn, error)
+
+ if d.NetDialContext != nil {
+ netDial = func(network, addr string) (net.Conn, error) {
+ return d.NetDialContext(ctx, network, addr)
+ }
+ } else if d.NetDial != nil {
+ netDial = d.NetDial
+ } else {
+ netDialer := &net.Dialer{}
+ netDial = func(network, addr string) (net.Conn, error) {
+ return netDialer.DialContext(ctx, network, addr)
+ }
+ }
+
+ // If needed, wrap the dial function to set the connection deadline.
+ if deadline, ok := ctx.Deadline(); ok {
+ forwardDial := netDial
+ netDial = func(network, addr string) (net.Conn, error) {
+ c, err := forwardDial(network, addr)
+ if err != nil {
+ return nil, err
+ }
+ err = c.SetDeadline(deadline)
+ if err != nil {
+ c.Close()
+ return nil, err
+ }
+ return c, nil
+ }
+ }
+
+ // If needed, wrap the dial function to connect through a proxy.
+ if d.Proxy != nil {
+ proxyURL, err := d.Proxy(req)
+ if err != nil {
+ return nil, nil, err
+ }
+ if proxyURL != nil {
+ dialer, err := proxy_FromURL(proxyURL, netDialerFunc(netDial))
+ if err != nil {
+ return nil, nil, err
+ }
+ netDial = dialer.Dial
+ }
+ }
+
+ hostPort, hostNoPort := hostPortNoPort(u)
+ trace := httptrace.ContextClientTrace(ctx)
+ if trace != nil && trace.GetConn != nil {
+ trace.GetConn(hostPort)
+ }
+
+ netConn, err := netDial("tcp", hostPort)
+ if trace != nil && trace.GotConn != nil {
+ trace.GotConn(httptrace.GotConnInfo{
+ Conn: netConn,
+ })
+ }
+ if err != nil {
+ return nil, nil, err
+ }
+
+ defer func() {
+ if netConn != nil {
+ netConn.Close()
+ }
+ }()
+
+ if u.Scheme == "https" {
+ cfg := cloneTLSConfig(d.TLSClientConfig)
+ if cfg.ServerName == "" {
+ cfg.ServerName = hostNoPort
+ }
+ tlsConn := tls.Client(netConn, cfg)
+ netConn = tlsConn
+
+ var err error
+ if trace != nil {
+ err = doHandshakeWithTrace(trace, tlsConn, cfg)
+ } else {
+ err = doHandshake(tlsConn, cfg)
+ }
+
+ if err != nil {
+ return nil, nil, err
+ }
+ }
+
+ conn := newConn(netConn, false, d.ReadBufferSize, d.WriteBufferSize, d.WriteBufferPool, nil, nil)
+
+ if err := req.Write(netConn); err != nil {
+ return nil, nil, err
+ }
+
+ if trace != nil && trace.GotFirstResponseByte != nil {
+ if peek, err := conn.br.Peek(1); err == nil && len(peek) == 1 {
+ trace.GotFirstResponseByte()
+ }
+ }
+
+ resp, err := http.ReadResponse(conn.br, req)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ if d.Jar != nil {
+ if rc := resp.Cookies(); len(rc) > 0 {
+ d.Jar.SetCookies(u, rc)
+ }
+ }
+
+ if resp.StatusCode != 101 ||
+ !strings.EqualFold(resp.Header.Get("Upgrade"), "websocket") ||
+ !strings.EqualFold(resp.Header.Get("Connection"), "upgrade") ||
+ resp.Header.Get("Sec-Websocket-Accept") != computeAcceptKey(challengeKey) {
+ // Before closing the network connection on return from this
+ // function, slurp up some of the response to aid application
+ // debugging.
+ buf := make([]byte, 1024)
+ n, _ := io.ReadFull(resp.Body, buf)
+ resp.Body = ioutil.NopCloser(bytes.NewReader(buf[:n]))
+ return nil, resp, ErrBadHandshake
+ }
+
+ for _, ext := range parseExtensions(resp.Header) {
+ if ext[""] != "permessage-deflate" {
+ continue
+ }
+ _, snct := ext["server_no_context_takeover"]
+ _, cnct := ext["client_no_context_takeover"]
+ if !snct || !cnct {
+ return nil, resp, errInvalidCompression
+ }
+ conn.newCompressionWriter = compressNoContextTakeover
+ conn.newDecompressionReader = decompressNoContextTakeover
+ break
+ }
+
+ resp.Body = ioutil.NopCloser(bytes.NewReader([]byte{}))
+ conn.subprotocol = resp.Header.Get("Sec-Websocket-Protocol")
+
+ netConn.SetDeadline(time.Time{})
+ netConn = nil // to avoid close in defer.
+ return conn, resp, nil
+}
+
+func doHandshake(tlsConn *tls.Conn, cfg *tls.Config) error {
+ if err := tlsConn.Handshake(); err != nil {
+ return err
+ }
+ if !cfg.InsecureSkipVerify {
+ if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
+ return err
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/gorilla/websocket/client_clone.go b/vendor/github.com/gorilla/websocket/client_clone.go
new file mode 100644
index 0000000000000..4f0d943723a9d
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/client_clone.go
@@ -0,0 +1,16 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.8
+
+package websocket
+
+import "crypto/tls"
+
+func cloneTLSConfig(cfg *tls.Config) *tls.Config {
+ if cfg == nil {
+ return &tls.Config{}
+ }
+ return cfg.Clone()
+}
diff --git a/vendor/github.com/gorilla/websocket/client_clone_legacy.go b/vendor/github.com/gorilla/websocket/client_clone_legacy.go
new file mode 100644
index 0000000000000..babb007fb4144
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/client_clone_legacy.go
@@ -0,0 +1,38 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.8
+
+package websocket
+
+import "crypto/tls"
+
+// cloneTLSConfig clones all public fields except the fields
+// SessionTicketsDisabled and SessionTicketKey. This avoids copying the
+// sync.Mutex in the sync.Once and makes it safe to call cloneTLSConfig on a
+// config in active use.
+func cloneTLSConfig(cfg *tls.Config) *tls.Config {
+ if cfg == nil {
+ return &tls.Config{}
+ }
+ return &tls.Config{
+ Rand: cfg.Rand,
+ Time: cfg.Time,
+ Certificates: cfg.Certificates,
+ NameToCertificate: cfg.NameToCertificate,
+ GetCertificate: cfg.GetCertificate,
+ RootCAs: cfg.RootCAs,
+ NextProtos: cfg.NextProtos,
+ ServerName: cfg.ServerName,
+ ClientAuth: cfg.ClientAuth,
+ ClientCAs: cfg.ClientCAs,
+ InsecureSkipVerify: cfg.InsecureSkipVerify,
+ CipherSuites: cfg.CipherSuites,
+ PreferServerCipherSuites: cfg.PreferServerCipherSuites,
+ ClientSessionCache: cfg.ClientSessionCache,
+ MinVersion: cfg.MinVersion,
+ MaxVersion: cfg.MaxVersion,
+ CurvePreferences: cfg.CurvePreferences,
+ }
+}
diff --git a/vendor/github.com/gorilla/websocket/compression.go b/vendor/github.com/gorilla/websocket/compression.go
new file mode 100644
index 0000000000000..813ffb1e84336
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/compression.go
@@ -0,0 +1,148 @@
+// Copyright 2017 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "compress/flate"
+ "errors"
+ "io"
+ "strings"
+ "sync"
+)
+
+const (
+ minCompressionLevel = -2 // flate.HuffmanOnly not defined in Go < 1.6
+ maxCompressionLevel = flate.BestCompression
+ defaultCompressionLevel = 1
+)
+
+var (
+ flateWriterPools [maxCompressionLevel - minCompressionLevel + 1]sync.Pool
+ flateReaderPool = sync.Pool{New: func() interface{} {
+ return flate.NewReader(nil)
+ }}
+)
+
+func decompressNoContextTakeover(r io.Reader) io.ReadCloser {
+ const tail =
+ // Add four bytes as specified in RFC
+ "\x00\x00\xff\xff" +
+ // Add final block to squelch unexpected EOF error from flate reader.
+ "\x01\x00\x00\xff\xff"
+
+ fr, _ := flateReaderPool.Get().(io.ReadCloser)
+ fr.(flate.Resetter).Reset(io.MultiReader(r, strings.NewReader(tail)), nil)
+ return &flateReadWrapper{fr}
+}
+
+func isValidCompressionLevel(level int) bool {
+ return minCompressionLevel <= level && level <= maxCompressionLevel
+}
+
+func compressNoContextTakeover(w io.WriteCloser, level int) io.WriteCloser {
+ p := &flateWriterPools[level-minCompressionLevel]
+ tw := &truncWriter{w: w}
+ fw, _ := p.Get().(*flate.Writer)
+ if fw == nil {
+ fw, _ = flate.NewWriter(tw, level)
+ } else {
+ fw.Reset(tw)
+ }
+ return &flateWriteWrapper{fw: fw, tw: tw, p: p}
+}
+
+// truncWriter is an io.Writer that writes all but the last four bytes of the
+// stream to another io.Writer.
+type truncWriter struct {
+ w io.WriteCloser
+ n int
+ p [4]byte
+}
+
+func (w *truncWriter) Write(p []byte) (int, error) {
+ n := 0
+
+ // fill buffer first for simplicity.
+ if w.n < len(w.p) {
+ n = copy(w.p[w.n:], p)
+ p = p[n:]
+ w.n += n
+ if len(p) == 0 {
+ return n, nil
+ }
+ }
+
+ m := len(p)
+ if m > len(w.p) {
+ m = len(w.p)
+ }
+
+ if nn, err := w.w.Write(w.p[:m]); err != nil {
+ return n + nn, err
+ }
+
+ copy(w.p[:], w.p[m:])
+ copy(w.p[len(w.p)-m:], p[len(p)-m:])
+ nn, err := w.w.Write(p[:len(p)-m])
+ return n + nn, err
+}
+
+type flateWriteWrapper struct {
+ fw *flate.Writer
+ tw *truncWriter
+ p *sync.Pool
+}
+
+func (w *flateWriteWrapper) Write(p []byte) (int, error) {
+ if w.fw == nil {
+ return 0, errWriteClosed
+ }
+ return w.fw.Write(p)
+}
+
+func (w *flateWriteWrapper) Close() error {
+ if w.fw == nil {
+ return errWriteClosed
+ }
+ err1 := w.fw.Flush()
+ w.p.Put(w.fw)
+ w.fw = nil
+ if w.tw.p != [4]byte{0, 0, 0xff, 0xff} {
+ return errors.New("websocket: internal error, unexpected bytes at end of flate stream")
+ }
+ err2 := w.tw.w.Close()
+ if err1 != nil {
+ return err1
+ }
+ return err2
+}
+
+type flateReadWrapper struct {
+ fr io.ReadCloser
+}
+
+func (r *flateReadWrapper) Read(p []byte) (int, error) {
+ if r.fr == nil {
+ return 0, io.ErrClosedPipe
+ }
+ n, err := r.fr.Read(p)
+ if err == io.EOF {
+ // Preemptively place the reader back in the pool. This helps with
+ // scenarios where the application does not call NextReader() soon after
+ // this final read.
+ r.Close()
+ }
+ return n, err
+}
+
+func (r *flateReadWrapper) Close() error {
+ if r.fr == nil {
+ return io.ErrClosedPipe
+ }
+ err := r.fr.Close()
+ flateReaderPool.Put(r.fr)
+ r.fr = nil
+ return err
+}
diff --git a/vendor/github.com/gorilla/websocket/conn.go b/vendor/github.com/gorilla/websocket/conn.go
new file mode 100644
index 0000000000000..ca46d2f793c24
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn.go
@@ -0,0 +1,1201 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bufio"
+ "encoding/binary"
+ "errors"
+ "io"
+ "io/ioutil"
+ "math/rand"
+ "net"
+ "strconv"
+ "sync"
+ "time"
+ "unicode/utf8"
+)
+
+const (
+ // Frame header byte 0 bits from Section 5.2 of RFC 6455
+ finalBit = 1 << 7
+ rsv1Bit = 1 << 6
+ rsv2Bit = 1 << 5
+ rsv3Bit = 1 << 4
+
+ // Frame header byte 1 bits from Section 5.2 of RFC 6455
+ maskBit = 1 << 7
+
+ maxFrameHeaderSize = 2 + 8 + 4 // Fixed header + length + mask
+ maxControlFramePayloadSize = 125
+
+ writeWait = time.Second
+
+ defaultReadBufferSize = 4096
+ defaultWriteBufferSize = 4096
+
+ continuationFrame = 0
+ noFrame = -1
+)
+
+// Close codes defined in RFC 6455, section 11.7.
+const (
+ CloseNormalClosure = 1000
+ CloseGoingAway = 1001
+ CloseProtocolError = 1002
+ CloseUnsupportedData = 1003
+ CloseNoStatusReceived = 1005
+ CloseAbnormalClosure = 1006
+ CloseInvalidFramePayloadData = 1007
+ ClosePolicyViolation = 1008
+ CloseMessageTooBig = 1009
+ CloseMandatoryExtension = 1010
+ CloseInternalServerErr = 1011
+ CloseServiceRestart = 1012
+ CloseTryAgainLater = 1013
+ CloseTLSHandshake = 1015
+)
+
+// The message types are defined in RFC 6455, section 11.8.
+const (
+ // TextMessage denotes a text data message. The text message payload is
+ // interpreted as UTF-8 encoded text data.
+ TextMessage = 1
+
+ // BinaryMessage denotes a binary data message.
+ BinaryMessage = 2
+
+ // CloseMessage denotes a close control message. The optional message
+ // payload contains a numeric code and text. Use the FormatCloseMessage
+ // function to format a close message payload.
+ CloseMessage = 8
+
+ // PingMessage denotes a ping control message. The optional message payload
+ // is UTF-8 encoded text.
+ PingMessage = 9
+
+ // PongMessage denotes a pong control message. The optional message payload
+ // is UTF-8 encoded text.
+ PongMessage = 10
+)
+
+// ErrCloseSent is returned when the application writes a message to the
+// connection after sending a close message.
+var ErrCloseSent = errors.New("websocket: close sent")
+
+// ErrReadLimit is returned when reading a message that is larger than the
+// read limit set for the connection.
+var ErrReadLimit = errors.New("websocket: read limit exceeded")
+
+// netError satisfies the net Error interface.
+type netError struct {
+ msg string
+ temporary bool
+ timeout bool
+}
+
+func (e *netError) Error() string { return e.msg }
+func (e *netError) Temporary() bool { return e.temporary }
+func (e *netError) Timeout() bool { return e.timeout }
+
+// CloseError represents a close message.
+type CloseError struct {
+ // Code is defined in RFC 6455, section 11.7.
+ Code int
+
+ // Text is the optional text payload.
+ Text string
+}
+
+func (e *CloseError) Error() string {
+ s := []byte("websocket: close ")
+ s = strconv.AppendInt(s, int64(e.Code), 10)
+ switch e.Code {
+ case CloseNormalClosure:
+ s = append(s, " (normal)"...)
+ case CloseGoingAway:
+ s = append(s, " (going away)"...)
+ case CloseProtocolError:
+ s = append(s, " (protocol error)"...)
+ case CloseUnsupportedData:
+ s = append(s, " (unsupported data)"...)
+ case CloseNoStatusReceived:
+ s = append(s, " (no status)"...)
+ case CloseAbnormalClosure:
+ s = append(s, " (abnormal closure)"...)
+ case CloseInvalidFramePayloadData:
+ s = append(s, " (invalid payload data)"...)
+ case ClosePolicyViolation:
+ s = append(s, " (policy violation)"...)
+ case CloseMessageTooBig:
+ s = append(s, " (message too big)"...)
+ case CloseMandatoryExtension:
+ s = append(s, " (mandatory extension missing)"...)
+ case CloseInternalServerErr:
+ s = append(s, " (internal server error)"...)
+ case CloseTLSHandshake:
+ s = append(s, " (TLS handshake error)"...)
+ }
+ if e.Text != "" {
+ s = append(s, ": "...)
+ s = append(s, e.Text...)
+ }
+ return string(s)
+}
+
+// IsCloseError returns boolean indicating whether the error is a *CloseError
+// with one of the specified codes.
+func IsCloseError(err error, codes ...int) bool {
+ if e, ok := err.(*CloseError); ok {
+ for _, code := range codes {
+ if e.Code == code {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// IsUnexpectedCloseError returns boolean indicating whether the error is a
+// *CloseError with a code not in the list of expected codes.
+func IsUnexpectedCloseError(err error, expectedCodes ...int) bool {
+ if e, ok := err.(*CloseError); ok {
+ for _, code := range expectedCodes {
+ if e.Code == code {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+}
+
+var (
+ errWriteTimeout = &netError{msg: "websocket: write timeout", timeout: true, temporary: true}
+ errUnexpectedEOF = &CloseError{Code: CloseAbnormalClosure, Text: io.ErrUnexpectedEOF.Error()}
+ errBadWriteOpCode = errors.New("websocket: bad write message type")
+ errWriteClosed = errors.New("websocket: write closed")
+ errInvalidControlFrame = errors.New("websocket: invalid control frame")
+)
+
+func newMaskKey() [4]byte {
+ n := rand.Uint32()
+ return [4]byte{byte(n), byte(n >> 8), byte(n >> 16), byte(n >> 24)}
+}
+
+func hideTempErr(err error) error {
+ if e, ok := err.(net.Error); ok && e.Temporary() {
+ err = &netError{msg: e.Error(), timeout: e.Timeout()}
+ }
+ return err
+}
+
+func isControl(frameType int) bool {
+ return frameType == CloseMessage || frameType == PingMessage || frameType == PongMessage
+}
+
+func isData(frameType int) bool {
+ return frameType == TextMessage || frameType == BinaryMessage
+}
+
+var validReceivedCloseCodes = map[int]bool{
+ // see http://www.iana.org/assignments/websocket/websocket.xhtml#close-code-number
+
+ CloseNormalClosure: true,
+ CloseGoingAway: true,
+ CloseProtocolError: true,
+ CloseUnsupportedData: true,
+ CloseNoStatusReceived: false,
+ CloseAbnormalClosure: false,
+ CloseInvalidFramePayloadData: true,
+ ClosePolicyViolation: true,
+ CloseMessageTooBig: true,
+ CloseMandatoryExtension: true,
+ CloseInternalServerErr: true,
+ CloseServiceRestart: true,
+ CloseTryAgainLater: true,
+ CloseTLSHandshake: false,
+}
+
+func isValidReceivedCloseCode(code int) bool {
+ return validReceivedCloseCodes[code] || (code >= 3000 && code <= 4999)
+}
+
+// BufferPool represents a pool of buffers. The *sync.Pool type satisfies this
+// interface. The type of the value stored in a pool is not specified.
+type BufferPool interface {
+ // Get gets a value from the pool or returns nil if the pool is empty.
+ Get() interface{}
+ // Put adds a value to the pool.
+ Put(interface{})
+}
+
+// writePoolData is the type added to the write buffer pool. This wrapper is
+// used to prevent applications from peeking at and depending on the values
+// added to the pool.
+type writePoolData struct{ buf []byte }
+
+// The Conn type represents a WebSocket connection.
+type Conn struct {
+ conn net.Conn
+ isServer bool
+ subprotocol string
+
+ // Write fields
+ mu chan struct{} // used as mutex to protect write to conn
+ writeBuf []byte // frame is constructed in this buffer.
+ writePool BufferPool
+ writeBufSize int
+ writeDeadline time.Time
+ writer io.WriteCloser // the current writer returned to the application
+ isWriting bool // for best-effort concurrent write detection
+
+ writeErrMu sync.Mutex
+ writeErr error
+
+ enableWriteCompression bool
+ compressionLevel int
+ newCompressionWriter func(io.WriteCloser, int) io.WriteCloser
+
+ // Read fields
+ reader io.ReadCloser // the current reader returned to the application
+ readErr error
+ br *bufio.Reader
+ // bytes remaining in current frame.
+ // set setReadRemaining to safely update this value and prevent overflow
+ readRemaining int64
+ readFinal bool // true the current message has more frames.
+ readLength int64 // Message size.
+ readLimit int64 // Maximum message size.
+ readMaskPos int
+ readMaskKey [4]byte
+ handlePong func(string) error
+ handlePing func(string) error
+ handleClose func(int, string) error
+ readErrCount int
+ messageReader *messageReader // the current low-level reader
+
+ readDecompress bool // whether last read frame had RSV1 set
+ newDecompressionReader func(io.Reader) io.ReadCloser
+}
+
+func newConn(conn net.Conn, isServer bool, readBufferSize, writeBufferSize int, writeBufferPool BufferPool, br *bufio.Reader, writeBuf []byte) *Conn {
+
+ if br == nil {
+ if readBufferSize == 0 {
+ readBufferSize = defaultReadBufferSize
+ } else if readBufferSize < maxControlFramePayloadSize {
+ // must be large enough for control frame
+ readBufferSize = maxControlFramePayloadSize
+ }
+ br = bufio.NewReaderSize(conn, readBufferSize)
+ }
+
+ if writeBufferSize <= 0 {
+ writeBufferSize = defaultWriteBufferSize
+ }
+ writeBufferSize += maxFrameHeaderSize
+
+ if writeBuf == nil && writeBufferPool == nil {
+ writeBuf = make([]byte, writeBufferSize)
+ }
+
+ mu := make(chan struct{}, 1)
+ mu <- struct{}{}
+ c := &Conn{
+ isServer: isServer,
+ br: br,
+ conn: conn,
+ mu: mu,
+ readFinal: true,
+ writeBuf: writeBuf,
+ writePool: writeBufferPool,
+ writeBufSize: writeBufferSize,
+ enableWriteCompression: true,
+ compressionLevel: defaultCompressionLevel,
+ }
+ c.SetCloseHandler(nil)
+ c.SetPingHandler(nil)
+ c.SetPongHandler(nil)
+ return c
+}
+
+// setReadRemaining tracks the number of bytes remaining on the connection. If n
+// overflows, an ErrReadLimit is returned.
+func (c *Conn) setReadRemaining(n int64) error {
+ if n < 0 {
+ return ErrReadLimit
+ }
+
+ c.readRemaining = n
+ return nil
+}
+
+// Subprotocol returns the negotiated protocol for the connection.
+func (c *Conn) Subprotocol() string {
+ return c.subprotocol
+}
+
+// Close closes the underlying network connection without sending or waiting
+// for a close message.
+func (c *Conn) Close() error {
+ return c.conn.Close()
+}
+
+// LocalAddr returns the local network address.
+func (c *Conn) LocalAddr() net.Addr {
+ return c.conn.LocalAddr()
+}
+
+// RemoteAddr returns the remote network address.
+func (c *Conn) RemoteAddr() net.Addr {
+ return c.conn.RemoteAddr()
+}
+
+// Write methods
+
+func (c *Conn) writeFatal(err error) error {
+ err = hideTempErr(err)
+ c.writeErrMu.Lock()
+ if c.writeErr == nil {
+ c.writeErr = err
+ }
+ c.writeErrMu.Unlock()
+ return err
+}
+
+func (c *Conn) read(n int) ([]byte, error) {
+ p, err := c.br.Peek(n)
+ if err == io.EOF {
+ err = errUnexpectedEOF
+ }
+ c.br.Discard(len(p))
+ return p, err
+}
+
+func (c *Conn) write(frameType int, deadline time.Time, buf0, buf1 []byte) error {
+ <-c.mu
+ defer func() { c.mu <- struct{}{} }()
+
+ c.writeErrMu.Lock()
+ err := c.writeErr
+ c.writeErrMu.Unlock()
+ if err != nil {
+ return err
+ }
+
+ c.conn.SetWriteDeadline(deadline)
+ if len(buf1) == 0 {
+ _, err = c.conn.Write(buf0)
+ } else {
+ err = c.writeBufs(buf0, buf1)
+ }
+ if err != nil {
+ return c.writeFatal(err)
+ }
+ if frameType == CloseMessage {
+ c.writeFatal(ErrCloseSent)
+ }
+ return nil
+}
+
+// WriteControl writes a control message with the given deadline. The allowed
+// message types are CloseMessage, PingMessage and PongMessage.
+func (c *Conn) WriteControl(messageType int, data []byte, deadline time.Time) error {
+ if !isControl(messageType) {
+ return errBadWriteOpCode
+ }
+ if len(data) > maxControlFramePayloadSize {
+ return errInvalidControlFrame
+ }
+
+ b0 := byte(messageType) | finalBit
+ b1 := byte(len(data))
+ if !c.isServer {
+ b1 |= maskBit
+ }
+
+ buf := make([]byte, 0, maxFrameHeaderSize+maxControlFramePayloadSize)
+ buf = append(buf, b0, b1)
+
+ if c.isServer {
+ buf = append(buf, data...)
+ } else {
+ key := newMaskKey()
+ buf = append(buf, key[:]...)
+ buf = append(buf, data...)
+ maskBytes(key, 0, buf[6:])
+ }
+
+ d := 1000 * time.Hour
+ if !deadline.IsZero() {
+ d = deadline.Sub(time.Now())
+ if d < 0 {
+ return errWriteTimeout
+ }
+ }
+
+ timer := time.NewTimer(d)
+ select {
+ case <-c.mu:
+ timer.Stop()
+ case <-timer.C:
+ return errWriteTimeout
+ }
+ defer func() { c.mu <- struct{}{} }()
+
+ c.writeErrMu.Lock()
+ err := c.writeErr
+ c.writeErrMu.Unlock()
+ if err != nil {
+ return err
+ }
+
+ c.conn.SetWriteDeadline(deadline)
+ _, err = c.conn.Write(buf)
+ if err != nil {
+ return c.writeFatal(err)
+ }
+ if messageType == CloseMessage {
+ c.writeFatal(ErrCloseSent)
+ }
+ return err
+}
+
+// beginMessage prepares a connection and message writer for a new message.
+func (c *Conn) beginMessage(mw *messageWriter, messageType int) error {
+ // Close previous writer if not already closed by the application. It's
+ // probably better to return an error in this situation, but we cannot
+ // change this without breaking existing applications.
+ if c.writer != nil {
+ c.writer.Close()
+ c.writer = nil
+ }
+
+ if !isControl(messageType) && !isData(messageType) {
+ return errBadWriteOpCode
+ }
+
+ c.writeErrMu.Lock()
+ err := c.writeErr
+ c.writeErrMu.Unlock()
+ if err != nil {
+ return err
+ }
+
+ mw.c = c
+ mw.frameType = messageType
+ mw.pos = maxFrameHeaderSize
+
+ if c.writeBuf == nil {
+ wpd, ok := c.writePool.Get().(writePoolData)
+ if ok {
+ c.writeBuf = wpd.buf
+ } else {
+ c.writeBuf = make([]byte, c.writeBufSize)
+ }
+ }
+ return nil
+}
+
+// NextWriter returns a writer for the next message to send. The writer's Close
+// method flushes the complete message to the network.
+//
+// There can be at most one open writer on a connection. NextWriter closes the
+// previous writer if the application has not already done so.
+//
+// All message types (TextMessage, BinaryMessage, CloseMessage, PingMessage and
+// PongMessage) are supported.
+func (c *Conn) NextWriter(messageType int) (io.WriteCloser, error) {
+ var mw messageWriter
+ if err := c.beginMessage(&mw, messageType); err != nil {
+ return nil, err
+ }
+ c.writer = &mw
+ if c.newCompressionWriter != nil && c.enableWriteCompression && isData(messageType) {
+ w := c.newCompressionWriter(c.writer, c.compressionLevel)
+ mw.compress = true
+ c.writer = w
+ }
+ return c.writer, nil
+}
+
+type messageWriter struct {
+ c *Conn
+ compress bool // whether next call to flushFrame should set RSV1
+ pos int // end of data in writeBuf.
+ frameType int // type of the current frame.
+ err error
+}
+
+func (w *messageWriter) endMessage(err error) error {
+ if w.err != nil {
+ return err
+ }
+ c := w.c
+ w.err = err
+ c.writer = nil
+ if c.writePool != nil {
+ c.writePool.Put(writePoolData{buf: c.writeBuf})
+ c.writeBuf = nil
+ }
+ return err
+}
+
+// flushFrame writes buffered data and extra as a frame to the network. The
+// final argument indicates that this is the last frame in the message.
+func (w *messageWriter) flushFrame(final bool, extra []byte) error {
+ c := w.c
+ length := w.pos - maxFrameHeaderSize + len(extra)
+
+ // Check for invalid control frames.
+ if isControl(w.frameType) &&
+ (!final || length > maxControlFramePayloadSize) {
+ return w.endMessage(errInvalidControlFrame)
+ }
+
+ b0 := byte(w.frameType)
+ if final {
+ b0 |= finalBit
+ }
+ if w.compress {
+ b0 |= rsv1Bit
+ }
+ w.compress = false
+
+ b1 := byte(0)
+ if !c.isServer {
+ b1 |= maskBit
+ }
+
+ // Assume that the frame starts at beginning of c.writeBuf.
+ framePos := 0
+ if c.isServer {
+ // Adjust up if mask not included in the header.
+ framePos = 4
+ }
+
+ switch {
+ case length >= 65536:
+ c.writeBuf[framePos] = b0
+ c.writeBuf[framePos+1] = b1 | 127
+ binary.BigEndian.PutUint64(c.writeBuf[framePos+2:], uint64(length))
+ case length > 125:
+ framePos += 6
+ c.writeBuf[framePos] = b0
+ c.writeBuf[framePos+1] = b1 | 126
+ binary.BigEndian.PutUint16(c.writeBuf[framePos+2:], uint16(length))
+ default:
+ framePos += 8
+ c.writeBuf[framePos] = b0
+ c.writeBuf[framePos+1] = b1 | byte(length)
+ }
+
+ if !c.isServer {
+ key := newMaskKey()
+ copy(c.writeBuf[maxFrameHeaderSize-4:], key[:])
+ maskBytes(key, 0, c.writeBuf[maxFrameHeaderSize:w.pos])
+ if len(extra) > 0 {
+ return w.endMessage(c.writeFatal(errors.New("websocket: internal error, extra used in client mode")))
+ }
+ }
+
+ // Write the buffers to the connection with best-effort detection of
+ // concurrent writes. See the concurrency section in the package
+ // documentation for more info.
+
+ if c.isWriting {
+ panic("concurrent write to websocket connection")
+ }
+ c.isWriting = true
+
+ err := c.write(w.frameType, c.writeDeadline, c.writeBuf[framePos:w.pos], extra)
+
+ if !c.isWriting {
+ panic("concurrent write to websocket connection")
+ }
+ c.isWriting = false
+
+ if err != nil {
+ return w.endMessage(err)
+ }
+
+ if final {
+ w.endMessage(errWriteClosed)
+ return nil
+ }
+
+ // Setup for next frame.
+ w.pos = maxFrameHeaderSize
+ w.frameType = continuationFrame
+ return nil
+}
+
+func (w *messageWriter) ncopy(max int) (int, error) {
+ n := len(w.c.writeBuf) - w.pos
+ if n <= 0 {
+ if err := w.flushFrame(false, nil); err != nil {
+ return 0, err
+ }
+ n = len(w.c.writeBuf) - w.pos
+ }
+ if n > max {
+ n = max
+ }
+ return n, nil
+}
+
+func (w *messageWriter) Write(p []byte) (int, error) {
+ if w.err != nil {
+ return 0, w.err
+ }
+
+ if len(p) > 2*len(w.c.writeBuf) && w.c.isServer {
+ // Don't buffer large messages.
+ err := w.flushFrame(false, p)
+ if err != nil {
+ return 0, err
+ }
+ return len(p), nil
+ }
+
+ nn := len(p)
+ for len(p) > 0 {
+ n, err := w.ncopy(len(p))
+ if err != nil {
+ return 0, err
+ }
+ copy(w.c.writeBuf[w.pos:], p[:n])
+ w.pos += n
+ p = p[n:]
+ }
+ return nn, nil
+}
+
+func (w *messageWriter) WriteString(p string) (int, error) {
+ if w.err != nil {
+ return 0, w.err
+ }
+
+ nn := len(p)
+ for len(p) > 0 {
+ n, err := w.ncopy(len(p))
+ if err != nil {
+ return 0, err
+ }
+ copy(w.c.writeBuf[w.pos:], p[:n])
+ w.pos += n
+ p = p[n:]
+ }
+ return nn, nil
+}
+
+func (w *messageWriter) ReadFrom(r io.Reader) (nn int64, err error) {
+ if w.err != nil {
+ return 0, w.err
+ }
+ for {
+ if w.pos == len(w.c.writeBuf) {
+ err = w.flushFrame(false, nil)
+ if err != nil {
+ break
+ }
+ }
+ var n int
+ n, err = r.Read(w.c.writeBuf[w.pos:])
+ w.pos += n
+ nn += int64(n)
+ if err != nil {
+ if err == io.EOF {
+ err = nil
+ }
+ break
+ }
+ }
+ return nn, err
+}
+
+func (w *messageWriter) Close() error {
+ if w.err != nil {
+ return w.err
+ }
+ return w.flushFrame(true, nil)
+}
+
+// WritePreparedMessage writes prepared message into connection.
+func (c *Conn) WritePreparedMessage(pm *PreparedMessage) error {
+ frameType, frameData, err := pm.frame(prepareKey{
+ isServer: c.isServer,
+ compress: c.newCompressionWriter != nil && c.enableWriteCompression && isData(pm.messageType),
+ compressionLevel: c.compressionLevel,
+ })
+ if err != nil {
+ return err
+ }
+ if c.isWriting {
+ panic("concurrent write to websocket connection")
+ }
+ c.isWriting = true
+ err = c.write(frameType, c.writeDeadline, frameData, nil)
+ if !c.isWriting {
+ panic("concurrent write to websocket connection")
+ }
+ c.isWriting = false
+ return err
+}
+
+// WriteMessage is a helper method for getting a writer using NextWriter,
+// writing the message and closing the writer.
+func (c *Conn) WriteMessage(messageType int, data []byte) error {
+
+ if c.isServer && (c.newCompressionWriter == nil || !c.enableWriteCompression) {
+ // Fast path with no allocations and single frame.
+
+ var mw messageWriter
+ if err := c.beginMessage(&mw, messageType); err != nil {
+ return err
+ }
+ n := copy(c.writeBuf[mw.pos:], data)
+ mw.pos += n
+ data = data[n:]
+ return mw.flushFrame(true, data)
+ }
+
+ w, err := c.NextWriter(messageType)
+ if err != nil {
+ return err
+ }
+ if _, err = w.Write(data); err != nil {
+ return err
+ }
+ return w.Close()
+}
+
+// SetWriteDeadline sets the write deadline on the underlying network
+// connection. After a write has timed out, the websocket state is corrupt and
+// all future writes will return an error. A zero value for t means writes will
+// not time out.
+func (c *Conn) SetWriteDeadline(t time.Time) error {
+ c.writeDeadline = t
+ return nil
+}
+
+// Read methods
+
+func (c *Conn) advanceFrame() (int, error) {
+ // 1. Skip remainder of previous frame.
+
+ if c.readRemaining > 0 {
+ if _, err := io.CopyN(ioutil.Discard, c.br, c.readRemaining); err != nil {
+ return noFrame, err
+ }
+ }
+
+ // 2. Read and parse first two bytes of frame header.
+
+ p, err := c.read(2)
+ if err != nil {
+ return noFrame, err
+ }
+
+ final := p[0]&finalBit != 0
+ frameType := int(p[0] & 0xf)
+ mask := p[1]&maskBit != 0
+ c.setReadRemaining(int64(p[1] & 0x7f))
+
+ c.readDecompress = false
+ if c.newDecompressionReader != nil && (p[0]&rsv1Bit) != 0 {
+ c.readDecompress = true
+ p[0] &^= rsv1Bit
+ }
+
+ if rsv := p[0] & (rsv1Bit | rsv2Bit | rsv3Bit); rsv != 0 {
+ return noFrame, c.handleProtocolError("unexpected reserved bits 0x" + strconv.FormatInt(int64(rsv), 16))
+ }
+
+ switch frameType {
+ case CloseMessage, PingMessage, PongMessage:
+ if c.readRemaining > maxControlFramePayloadSize {
+ return noFrame, c.handleProtocolError("control frame length > 125")
+ }
+ if !final {
+ return noFrame, c.handleProtocolError("control frame not final")
+ }
+ case TextMessage, BinaryMessage:
+ if !c.readFinal {
+ return noFrame, c.handleProtocolError("message start before final message frame")
+ }
+ c.readFinal = final
+ case continuationFrame:
+ if c.readFinal {
+ return noFrame, c.handleProtocolError("continuation after final message frame")
+ }
+ c.readFinal = final
+ default:
+ return noFrame, c.handleProtocolError("unknown opcode " + strconv.Itoa(frameType))
+ }
+
+ // 3. Read and parse frame length as per
+ // https://tools.ietf.org/html/rfc6455#section-5.2
+ //
+ // The length of the "Payload data", in bytes: if 0-125, that is the payload
+ // length.
+ // - If 126, the following 2 bytes interpreted as a 16-bit unsigned
+ // integer are the payload length.
+ // - If 127, the following 8 bytes interpreted as
+ // a 64-bit unsigned integer (the most significant bit MUST be 0) are the
+ // payload length. Multibyte length quantities are expressed in network byte
+ // order.
+
+ switch c.readRemaining {
+ case 126:
+ p, err := c.read(2)
+ if err != nil {
+ return noFrame, err
+ }
+
+ if err := c.setReadRemaining(int64(binary.BigEndian.Uint16(p))); err != nil {
+ return noFrame, err
+ }
+ case 127:
+ p, err := c.read(8)
+ if err != nil {
+ return noFrame, err
+ }
+
+ if err := c.setReadRemaining(int64(binary.BigEndian.Uint64(p))); err != nil {
+ return noFrame, err
+ }
+ }
+
+ // 4. Handle frame masking.
+
+ if mask != c.isServer {
+ return noFrame, c.handleProtocolError("incorrect mask flag")
+ }
+
+ if mask {
+ c.readMaskPos = 0
+ p, err := c.read(len(c.readMaskKey))
+ if err != nil {
+ return noFrame, err
+ }
+ copy(c.readMaskKey[:], p)
+ }
+
+ // 5. For text and binary messages, enforce read limit and return.
+
+ if frameType == continuationFrame || frameType == TextMessage || frameType == BinaryMessage {
+
+ c.readLength += c.readRemaining
+ // Don't allow readLength to overflow in the presence of a large readRemaining
+ // counter.
+ if c.readLength < 0 {
+ return noFrame, ErrReadLimit
+ }
+
+ if c.readLimit > 0 && c.readLength > c.readLimit {
+ c.WriteControl(CloseMessage, FormatCloseMessage(CloseMessageTooBig, ""), time.Now().Add(writeWait))
+ return noFrame, ErrReadLimit
+ }
+
+ return frameType, nil
+ }
+
+ // 6. Read control frame payload.
+
+ var payload []byte
+ if c.readRemaining > 0 {
+ payload, err = c.read(int(c.readRemaining))
+ c.setReadRemaining(0)
+ if err != nil {
+ return noFrame, err
+ }
+ if c.isServer {
+ maskBytes(c.readMaskKey, 0, payload)
+ }
+ }
+
+ // 7. Process control frame payload.
+
+ switch frameType {
+ case PongMessage:
+ if err := c.handlePong(string(payload)); err != nil {
+ return noFrame, err
+ }
+ case PingMessage:
+ if err := c.handlePing(string(payload)); err != nil {
+ return noFrame, err
+ }
+ case CloseMessage:
+ closeCode := CloseNoStatusReceived
+ closeText := ""
+ if len(payload) >= 2 {
+ closeCode = int(binary.BigEndian.Uint16(payload))
+ if !isValidReceivedCloseCode(closeCode) {
+ return noFrame, c.handleProtocolError("invalid close code")
+ }
+ closeText = string(payload[2:])
+ if !utf8.ValidString(closeText) {
+ return noFrame, c.handleProtocolError("invalid utf8 payload in close frame")
+ }
+ }
+ if err := c.handleClose(closeCode, closeText); err != nil {
+ return noFrame, err
+ }
+ return noFrame, &CloseError{Code: closeCode, Text: closeText}
+ }
+
+ return frameType, nil
+}
+
+func (c *Conn) handleProtocolError(message string) error {
+ c.WriteControl(CloseMessage, FormatCloseMessage(CloseProtocolError, message), time.Now().Add(writeWait))
+ return errors.New("websocket: " + message)
+}
+
+// NextReader returns the next data message received from the peer. The
+// returned messageType is either TextMessage or BinaryMessage.
+//
+// There can be at most one open reader on a connection. NextReader discards
+// the previous message if the application has not already consumed it.
+//
+// Applications must break out of the application's read loop when this method
+// returns a non-nil error value. Errors returned from this method are
+// permanent. Once this method returns a non-nil error, all subsequent calls to
+// this method return the same error.
+func (c *Conn) NextReader() (messageType int, r io.Reader, err error) {
+ // Close previous reader, only relevant for decompression.
+ if c.reader != nil {
+ c.reader.Close()
+ c.reader = nil
+ }
+
+ c.messageReader = nil
+ c.readLength = 0
+
+ for c.readErr == nil {
+ frameType, err := c.advanceFrame()
+ if err != nil {
+ c.readErr = hideTempErr(err)
+ break
+ }
+
+ if frameType == TextMessage || frameType == BinaryMessage {
+ c.messageReader = &messageReader{c}
+ c.reader = c.messageReader
+ if c.readDecompress {
+ c.reader = c.newDecompressionReader(c.reader)
+ }
+ return frameType, c.reader, nil
+ }
+ }
+
+ // Applications that do handle the error returned from this method spin in
+ // tight loop on connection failure. To help application developers detect
+ // this error, panic on repeated reads to the failed connection.
+ c.readErrCount++
+ if c.readErrCount >= 1000 {
+ panic("repeated read on failed websocket connection")
+ }
+
+ return noFrame, nil, c.readErr
+}
+
+type messageReader struct{ c *Conn }
+
+func (r *messageReader) Read(b []byte) (int, error) {
+ c := r.c
+ if c.messageReader != r {
+ return 0, io.EOF
+ }
+
+ for c.readErr == nil {
+
+ if c.readRemaining > 0 {
+ if int64(len(b)) > c.readRemaining {
+ b = b[:c.readRemaining]
+ }
+ n, err := c.br.Read(b)
+ c.readErr = hideTempErr(err)
+ if c.isServer {
+ c.readMaskPos = maskBytes(c.readMaskKey, c.readMaskPos, b[:n])
+ }
+ rem := c.readRemaining
+ rem -= int64(n)
+ c.setReadRemaining(rem)
+ if c.readRemaining > 0 && c.readErr == io.EOF {
+ c.readErr = errUnexpectedEOF
+ }
+ return n, c.readErr
+ }
+
+ if c.readFinal {
+ c.messageReader = nil
+ return 0, io.EOF
+ }
+
+ frameType, err := c.advanceFrame()
+ switch {
+ case err != nil:
+ c.readErr = hideTempErr(err)
+ case frameType == TextMessage || frameType == BinaryMessage:
+ c.readErr = errors.New("websocket: internal error, unexpected text or binary in Reader")
+ }
+ }
+
+ err := c.readErr
+ if err == io.EOF && c.messageReader == r {
+ err = errUnexpectedEOF
+ }
+ return 0, err
+}
+
+func (r *messageReader) Close() error {
+ return nil
+}
+
+// ReadMessage is a helper method for getting a reader using NextReader and
+// reading from that reader to a buffer.
+func (c *Conn) ReadMessage() (messageType int, p []byte, err error) {
+ var r io.Reader
+ messageType, r, err = c.NextReader()
+ if err != nil {
+ return messageType, nil, err
+ }
+ p, err = ioutil.ReadAll(r)
+ return messageType, p, err
+}
+
+// SetReadDeadline sets the read deadline on the underlying network connection.
+// After a read has timed out, the websocket connection state is corrupt and
+// all future reads will return an error. A zero value for t means reads will
+// not time out.
+func (c *Conn) SetReadDeadline(t time.Time) error {
+ return c.conn.SetReadDeadline(t)
+}
+
+// SetReadLimit sets the maximum size in bytes for a message read from the peer. If a
+// message exceeds the limit, the connection sends a close message to the peer
+// and returns ErrReadLimit to the application.
+func (c *Conn) SetReadLimit(limit int64) {
+ c.readLimit = limit
+}
+
+// CloseHandler returns the current close handler
+func (c *Conn) CloseHandler() func(code int, text string) error {
+ return c.handleClose
+}
+
+// SetCloseHandler sets the handler for close messages received from the peer.
+// The code argument to h is the received close code or CloseNoStatusReceived
+// if the close message is empty. The default close handler sends a close
+// message back to the peer.
+//
+// The handler function is called from the NextReader, ReadMessage and message
+// reader Read methods. The application must read the connection to process
+// close messages as described in the section on Control Messages above.
+//
+// The connection read methods return a CloseError when a close message is
+// received. Most applications should handle close messages as part of their
+// normal error handling. Applications should only set a close handler when the
+// application must perform some action before sending a close message back to
+// the peer.
+func (c *Conn) SetCloseHandler(h func(code int, text string) error) {
+ if h == nil {
+ h = func(code int, text string) error {
+ message := FormatCloseMessage(code, "")
+ c.WriteControl(CloseMessage, message, time.Now().Add(writeWait))
+ return nil
+ }
+ }
+ c.handleClose = h
+}
+
+// PingHandler returns the current ping handler
+func (c *Conn) PingHandler() func(appData string) error {
+ return c.handlePing
+}
+
+// SetPingHandler sets the handler for ping messages received from the peer.
+// The appData argument to h is the PING message application data. The default
+// ping handler sends a pong to the peer.
+//
+// The handler function is called from the NextReader, ReadMessage and message
+// reader Read methods. The application must read the connection to process
+// ping messages as described in the section on Control Messages above.
+func (c *Conn) SetPingHandler(h func(appData string) error) {
+ if h == nil {
+ h = func(message string) error {
+ err := c.WriteControl(PongMessage, []byte(message), time.Now().Add(writeWait))
+ if err == ErrCloseSent {
+ return nil
+ } else if e, ok := err.(net.Error); ok && e.Temporary() {
+ return nil
+ }
+ return err
+ }
+ }
+ c.handlePing = h
+}
+
+// PongHandler returns the current pong handler
+func (c *Conn) PongHandler() func(appData string) error {
+ return c.handlePong
+}
+
+// SetPongHandler sets the handler for pong messages received from the peer.
+// The appData argument to h is the PONG message application data. The default
+// pong handler does nothing.
+//
+// The handler function is called from the NextReader, ReadMessage and message
+// reader Read methods. The application must read the connection to process
+// pong messages as described in the section on Control Messages above.
+func (c *Conn) SetPongHandler(h func(appData string) error) {
+ if h == nil {
+ h = func(string) error { return nil }
+ }
+ c.handlePong = h
+}
+
+// UnderlyingConn returns the internal net.Conn. This can be used to further
+// modifications to connection specific flags.
+func (c *Conn) UnderlyingConn() net.Conn {
+ return c.conn
+}
+
+// EnableWriteCompression enables and disables write compression of
+// subsequent text and binary messages. This function is a noop if
+// compression was not negotiated with the peer.
+func (c *Conn) EnableWriteCompression(enable bool) {
+ c.enableWriteCompression = enable
+}
+
+// SetCompressionLevel sets the flate compression level for subsequent text and
+// binary messages. This function is a noop if compression was not negotiated
+// with the peer. See the compress/flate package for a description of
+// compression levels.
+func (c *Conn) SetCompressionLevel(level int) error {
+ if !isValidCompressionLevel(level) {
+ return errors.New("websocket: invalid compression level")
+ }
+ c.compressionLevel = level
+ return nil
+}
+
+// FormatCloseMessage formats closeCode and text as a WebSocket close message.
+// An empty message is returned for code CloseNoStatusReceived.
+func FormatCloseMessage(closeCode int, text string) []byte {
+ if closeCode == CloseNoStatusReceived {
+ // Return empty message because it's illegal to send
+ // CloseNoStatusReceived. Return non-nil value in case application
+ // checks for nil.
+ return []byte{}
+ }
+ buf := make([]byte, 2+len(text))
+ binary.BigEndian.PutUint16(buf, uint16(closeCode))
+ copy(buf[2:], text)
+ return buf
+}
diff --git a/vendor/github.com/gorilla/websocket/conn_write.go b/vendor/github.com/gorilla/websocket/conn_write.go
new file mode 100644
index 0000000000000..a509a21f87af3
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn_write.go
@@ -0,0 +1,15 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.8
+
+package websocket
+
+import "net"
+
+func (c *Conn) writeBufs(bufs ...[]byte) error {
+ b := net.Buffers(bufs)
+ _, err := b.WriteTo(c.conn)
+ return err
+}
diff --git a/vendor/github.com/gorilla/websocket/conn_write_legacy.go b/vendor/github.com/gorilla/websocket/conn_write_legacy.go
new file mode 100644
index 0000000000000..37edaff5a578a
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/conn_write_legacy.go
@@ -0,0 +1,18 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.8
+
+package websocket
+
+func (c *Conn) writeBufs(bufs ...[]byte) error {
+ for _, buf := range bufs {
+ if len(buf) > 0 {
+ if _, err := c.conn.Write(buf); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/gorilla/websocket/doc.go b/vendor/github.com/gorilla/websocket/doc.go
new file mode 100644
index 0000000000000..8db0cef95a29a
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/doc.go
@@ -0,0 +1,227 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package websocket implements the WebSocket protocol defined in RFC 6455.
+//
+// Overview
+//
+// The Conn type represents a WebSocket connection. A server application calls
+// the Upgrader.Upgrade method from an HTTP request handler to get a *Conn:
+//
+// var upgrader = websocket.Upgrader{
+// ReadBufferSize: 1024,
+// WriteBufferSize: 1024,
+// }
+//
+// func handler(w http.ResponseWriter, r *http.Request) {
+// conn, err := upgrader.Upgrade(w, r, nil)
+// if err != nil {
+// log.Println(err)
+// return
+// }
+// ... Use conn to send and receive messages.
+// }
+//
+// Call the connection's WriteMessage and ReadMessage methods to send and
+// receive messages as a slice of bytes. This snippet of code shows how to echo
+// messages using these methods:
+//
+// for {
+// messageType, p, err := conn.ReadMessage()
+// if err != nil {
+// log.Println(err)
+// return
+// }
+// if err := conn.WriteMessage(messageType, p); err != nil {
+// log.Println(err)
+// return
+// }
+// }
+//
+// In above snippet of code, p is a []byte and messageType is an int with value
+// websocket.BinaryMessage or websocket.TextMessage.
+//
+// An application can also send and receive messages using the io.WriteCloser
+// and io.Reader interfaces. To send a message, call the connection NextWriter
+// method to get an io.WriteCloser, write the message to the writer and close
+// the writer when done. To receive a message, call the connection NextReader
+// method to get an io.Reader and read until io.EOF is returned. This snippet
+// shows how to echo messages using the NextWriter and NextReader methods:
+//
+// for {
+// messageType, r, err := conn.NextReader()
+// if err != nil {
+// return
+// }
+// w, err := conn.NextWriter(messageType)
+// if err != nil {
+// return err
+// }
+// if _, err := io.Copy(w, r); err != nil {
+// return err
+// }
+// if err := w.Close(); err != nil {
+// return err
+// }
+// }
+//
+// Data Messages
+//
+// The WebSocket protocol distinguishes between text and binary data messages.
+// Text messages are interpreted as UTF-8 encoded text. The interpretation of
+// binary messages is left to the application.
+//
+// This package uses the TextMessage and BinaryMessage integer constants to
+// identify the two data message types. The ReadMessage and NextReader methods
+// return the type of the received message. The messageType argument to the
+// WriteMessage and NextWriter methods specifies the type of a sent message.
+//
+// It is the application's responsibility to ensure that text messages are
+// valid UTF-8 encoded text.
+//
+// Control Messages
+//
+// The WebSocket protocol defines three types of control messages: close, ping
+// and pong. Call the connection WriteControl, WriteMessage or NextWriter
+// methods to send a control message to the peer.
+//
+// Connections handle received close messages by calling the handler function
+// set with the SetCloseHandler method and by returning a *CloseError from the
+// NextReader, ReadMessage or the message Read method. The default close
+// handler sends a close message to the peer.
+//
+// Connections handle received ping messages by calling the handler function
+// set with the SetPingHandler method. The default ping handler sends a pong
+// message to the peer.
+//
+// Connections handle received pong messages by calling the handler function
+// set with the SetPongHandler method. The default pong handler does nothing.
+// If an application sends ping messages, then the application should set a
+// pong handler to receive the corresponding pong.
+//
+// The control message handler functions are called from the NextReader,
+// ReadMessage and message reader Read methods. The default close and ping
+// handlers can block these methods for a short time when the handler writes to
+// the connection.
+//
+// The application must read the connection to process close, ping and pong
+// messages sent from the peer. If the application is not otherwise interested
+// in messages from the peer, then the application should start a goroutine to
+// read and discard messages from the peer. A simple example is:
+//
+// func readLoop(c *websocket.Conn) {
+// for {
+// if _, _, err := c.NextReader(); err != nil {
+// c.Close()
+// break
+// }
+// }
+// }
+//
+// Concurrency
+//
+// Connections support one concurrent reader and one concurrent writer.
+//
+// Applications are responsible for ensuring that no more than one goroutine
+// calls the write methods (NextWriter, SetWriteDeadline, WriteMessage,
+// WriteJSON, EnableWriteCompression, SetCompressionLevel) concurrently and
+// that no more than one goroutine calls the read methods (NextReader,
+// SetReadDeadline, ReadMessage, ReadJSON, SetPongHandler, SetPingHandler)
+// concurrently.
+//
+// The Close and WriteControl methods can be called concurrently with all other
+// methods.
+//
+// Origin Considerations
+//
+// Web browsers allow Javascript applications to open a WebSocket connection to
+// any host. It's up to the server to enforce an origin policy using the Origin
+// request header sent by the browser.
+//
+// The Upgrader calls the function specified in the CheckOrigin field to check
+// the origin. If the CheckOrigin function returns false, then the Upgrade
+// method fails the WebSocket handshake with HTTP status 403.
+//
+// If the CheckOrigin field is nil, then the Upgrader uses a safe default: fail
+// the handshake if the Origin request header is present and the Origin host is
+// not equal to the Host request header.
+//
+// The deprecated package-level Upgrade function does not perform origin
+// checking. The application is responsible for checking the Origin header
+// before calling the Upgrade function.
+//
+// Buffers
+//
+// Connections buffer network input and output to reduce the number
+// of system calls when reading or writing messages.
+//
+// Write buffers are also used for constructing WebSocket frames. See RFC 6455,
+// Section 5 for a discussion of message framing. A WebSocket frame header is
+// written to the network each time a write buffer is flushed to the network.
+// Decreasing the size of the write buffer can increase the amount of framing
+// overhead on the connection.
+//
+// The buffer sizes in bytes are specified by the ReadBufferSize and
+// WriteBufferSize fields in the Dialer and Upgrader. The Dialer uses a default
+// size of 4096 when a buffer size field is set to zero. The Upgrader reuses
+// buffers created by the HTTP server when a buffer size field is set to zero.
+// The HTTP server buffers have a size of 4096 at the time of this writing.
+//
+// The buffer sizes do not limit the size of a message that can be read or
+// written by a connection.
+//
+// Buffers are held for the lifetime of the connection by default. If the
+// Dialer or Upgrader WriteBufferPool field is set, then a connection holds the
+// write buffer only when writing a message.
+//
+// Applications should tune the buffer sizes to balance memory use and
+// performance. Increasing the buffer size uses more memory, but can reduce the
+// number of system calls to read or write the network. In the case of writing,
+// increasing the buffer size can reduce the number of frame headers written to
+// the network.
+//
+// Some guidelines for setting buffer parameters are:
+//
+// Limit the buffer sizes to the maximum expected message size. Buffers larger
+// than the largest message do not provide any benefit.
+//
+// Depending on the distribution of message sizes, setting the buffer size to
+// a value less than the maximum expected message size can greatly reduce memory
+// use with a small impact on performance. Here's an example: If 99% of the
+// messages are smaller than 256 bytes and the maximum message size is 512
+// bytes, then a buffer size of 256 bytes will result in 1.01 more system calls
+// than a buffer size of 512 bytes. The memory savings is 50%.
+//
+// A write buffer pool is useful when the application has a modest number
+// writes over a large number of connections. when buffers are pooled, a larger
+// buffer size has a reduced impact on total memory use and has the benefit of
+// reducing system calls and frame overhead.
+//
+// Compression EXPERIMENTAL
+//
+// Per message compression extensions (RFC 7692) are experimentally supported
+// by this package in a limited capacity. Setting the EnableCompression option
+// to true in Dialer or Upgrader will attempt to negotiate per message deflate
+// support.
+//
+// var upgrader = websocket.Upgrader{
+// EnableCompression: true,
+// }
+//
+// If compression was successfully negotiated with the connection's peer, any
+// message received in compressed form will be automatically decompressed.
+// All Read methods will return uncompressed bytes.
+//
+// Per message compression of messages written to a connection can be enabled
+// or disabled by calling the corresponding Conn method:
+//
+// conn.EnableWriteCompression(false)
+//
+// Currently this package does not support compression with "context takeover".
+// This means that messages must be compressed and decompressed in isolation,
+// without retaining sliding window or dictionary state across messages. For
+// more details refer to RFC 7692.
+//
+// Use of compression is experimental and may result in decreased performance.
+package websocket
diff --git a/vendor/github.com/gorilla/websocket/go.mod b/vendor/github.com/gorilla/websocket/go.mod
new file mode 100644
index 0000000000000..1a7afd5028a7a
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/go.mod
@@ -0,0 +1,3 @@
+module github.com/gorilla/websocket
+
+go 1.12
diff --git a/vendor/github.com/gorilla/websocket/go.sum b/vendor/github.com/gorilla/websocket/go.sum
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/vendor/github.com/gorilla/websocket/join.go b/vendor/github.com/gorilla/websocket/join.go
new file mode 100644
index 0000000000000..c64f8c82901a3
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/join.go
@@ -0,0 +1,42 @@
+// Copyright 2019 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "io"
+ "strings"
+)
+
+// JoinMessages concatenates received messages to create a single io.Reader.
+// The string term is appended to each message. The returned reader does not
+// support concurrent calls to the Read method.
+func JoinMessages(c *Conn, term string) io.Reader {
+ return &joinReader{c: c, term: term}
+}
+
+type joinReader struct {
+ c *Conn
+ term string
+ r io.Reader
+}
+
+func (r *joinReader) Read(p []byte) (int, error) {
+ if r.r == nil {
+ var err error
+ _, r.r, err = r.c.NextReader()
+ if err != nil {
+ return 0, err
+ }
+ if r.term != "" {
+ r.r = io.MultiReader(r.r, strings.NewReader(r.term))
+ }
+ }
+ n, err := r.r.Read(p)
+ if err == io.EOF {
+ err = nil
+ r.r = nil
+ }
+ return n, err
+}
diff --git a/vendor/github.com/gorilla/websocket/json.go b/vendor/github.com/gorilla/websocket/json.go
new file mode 100644
index 0000000000000..dc2c1f6415ff8
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/json.go
@@ -0,0 +1,60 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "encoding/json"
+ "io"
+)
+
+// WriteJSON writes the JSON encoding of v as a message.
+//
+// Deprecated: Use c.WriteJSON instead.
+func WriteJSON(c *Conn, v interface{}) error {
+ return c.WriteJSON(v)
+}
+
+// WriteJSON writes the JSON encoding of v as a message.
+//
+// See the documentation for encoding/json Marshal for details about the
+// conversion of Go values to JSON.
+func (c *Conn) WriteJSON(v interface{}) error {
+ w, err := c.NextWriter(TextMessage)
+ if err != nil {
+ return err
+ }
+ err1 := json.NewEncoder(w).Encode(v)
+ err2 := w.Close()
+ if err1 != nil {
+ return err1
+ }
+ return err2
+}
+
+// ReadJSON reads the next JSON-encoded message from the connection and stores
+// it in the value pointed to by v.
+//
+// Deprecated: Use c.ReadJSON instead.
+func ReadJSON(c *Conn, v interface{}) error {
+ return c.ReadJSON(v)
+}
+
+// ReadJSON reads the next JSON-encoded message from the connection and stores
+// it in the value pointed to by v.
+//
+// See the documentation for the encoding/json Unmarshal function for details
+// about the conversion of JSON to a Go value.
+func (c *Conn) ReadJSON(v interface{}) error {
+ _, r, err := c.NextReader()
+ if err != nil {
+ return err
+ }
+ err = json.NewDecoder(r).Decode(v)
+ if err == io.EOF {
+ // One value is expected in the message.
+ err = io.ErrUnexpectedEOF
+ }
+ return err
+}
diff --git a/vendor/github.com/gorilla/websocket/mask.go b/vendor/github.com/gorilla/websocket/mask.go
new file mode 100644
index 0000000000000..577fce9efd720
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/mask.go
@@ -0,0 +1,54 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved. Use of
+// this source code is governed by a BSD-style license that can be found in the
+// LICENSE file.
+
+// +build !appengine
+
+package websocket
+
+import "unsafe"
+
+const wordSize = int(unsafe.Sizeof(uintptr(0)))
+
+func maskBytes(key [4]byte, pos int, b []byte) int {
+ // Mask one byte at a time for small buffers.
+ if len(b) < 2*wordSize {
+ for i := range b {
+ b[i] ^= key[pos&3]
+ pos++
+ }
+ return pos & 3
+ }
+
+ // Mask one byte at a time to word boundary.
+ if n := int(uintptr(unsafe.Pointer(&b[0]))) % wordSize; n != 0 {
+ n = wordSize - n
+ for i := range b[:n] {
+ b[i] ^= key[pos&3]
+ pos++
+ }
+ b = b[n:]
+ }
+
+ // Create aligned word size key.
+ var k [wordSize]byte
+ for i := range k {
+ k[i] = key[(pos+i)&3]
+ }
+ kw := *(*uintptr)(unsafe.Pointer(&k))
+
+ // Mask one word at a time.
+ n := (len(b) / wordSize) * wordSize
+ for i := 0; i < n; i += wordSize {
+ *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(i))) ^= kw
+ }
+
+ // Mask one byte at a time for remaining bytes.
+ b = b[n:]
+ for i := range b {
+ b[i] ^= key[pos&3]
+ pos++
+ }
+
+ return pos & 3
+}
diff --git a/vendor/github.com/gorilla/websocket/mask_safe.go b/vendor/github.com/gorilla/websocket/mask_safe.go
new file mode 100644
index 0000000000000..2aac060e52e70
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/mask_safe.go
@@ -0,0 +1,15 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved. Use of
+// this source code is governed by a BSD-style license that can be found in the
+// LICENSE file.
+
+// +build appengine
+
+package websocket
+
+func maskBytes(key [4]byte, pos int, b []byte) int {
+ for i := range b {
+ b[i] ^= key[pos&3]
+ pos++
+ }
+ return pos & 3
+}
diff --git a/vendor/github.com/gorilla/websocket/prepared.go b/vendor/github.com/gorilla/websocket/prepared.go
new file mode 100644
index 0000000000000..c854225e9676f
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/prepared.go
@@ -0,0 +1,102 @@
+// Copyright 2017 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bytes"
+ "net"
+ "sync"
+ "time"
+)
+
+// PreparedMessage caches on the wire representations of a message payload.
+// Use PreparedMessage to efficiently send a message payload to multiple
+// connections. PreparedMessage is especially useful when compression is used
+// because the CPU and memory expensive compression operation can be executed
+// once for a given set of compression options.
+type PreparedMessage struct {
+ messageType int
+ data []byte
+ mu sync.Mutex
+ frames map[prepareKey]*preparedFrame
+}
+
+// prepareKey defines a unique set of options to cache prepared frames in PreparedMessage.
+type prepareKey struct {
+ isServer bool
+ compress bool
+ compressionLevel int
+}
+
+// preparedFrame contains data in wire representation.
+type preparedFrame struct {
+ once sync.Once
+ data []byte
+}
+
+// NewPreparedMessage returns an initialized PreparedMessage. You can then send
+// it to connection using WritePreparedMessage method. Valid wire
+// representation will be calculated lazily only once for a set of current
+// connection options.
+func NewPreparedMessage(messageType int, data []byte) (*PreparedMessage, error) {
+ pm := &PreparedMessage{
+ messageType: messageType,
+ frames: make(map[prepareKey]*preparedFrame),
+ data: data,
+ }
+
+ // Prepare a plain server frame.
+ _, frameData, err := pm.frame(prepareKey{isServer: true, compress: false})
+ if err != nil {
+ return nil, err
+ }
+
+ // To protect against caller modifying the data argument, remember the data
+ // copied to the plain server frame.
+ pm.data = frameData[len(frameData)-len(data):]
+ return pm, nil
+}
+
+func (pm *PreparedMessage) frame(key prepareKey) (int, []byte, error) {
+ pm.mu.Lock()
+ frame, ok := pm.frames[key]
+ if !ok {
+ frame = &preparedFrame{}
+ pm.frames[key] = frame
+ }
+ pm.mu.Unlock()
+
+ var err error
+ frame.once.Do(func() {
+ // Prepare a frame using a 'fake' connection.
+ // TODO: Refactor code in conn.go to allow more direct construction of
+ // the frame.
+ mu := make(chan struct{}, 1)
+ mu <- struct{}{}
+ var nc prepareConn
+ c := &Conn{
+ conn: &nc,
+ mu: mu,
+ isServer: key.isServer,
+ compressionLevel: key.compressionLevel,
+ enableWriteCompression: true,
+ writeBuf: make([]byte, defaultWriteBufferSize+maxFrameHeaderSize),
+ }
+ if key.compress {
+ c.newCompressionWriter = compressNoContextTakeover
+ }
+ err = c.WriteMessage(pm.messageType, pm.data)
+ frame.data = nc.buf.Bytes()
+ })
+ return pm.messageType, frame.data, err
+}
+
+type prepareConn struct {
+ buf bytes.Buffer
+ net.Conn
+}
+
+func (pc *prepareConn) Write(p []byte) (int, error) { return pc.buf.Write(p) }
+func (pc *prepareConn) SetWriteDeadline(t time.Time) error { return nil }
diff --git a/vendor/github.com/gorilla/websocket/proxy.go b/vendor/github.com/gorilla/websocket/proxy.go
new file mode 100644
index 0000000000000..e87a8c9f0c96e
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/proxy.go
@@ -0,0 +1,77 @@
+// Copyright 2017 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bufio"
+ "encoding/base64"
+ "errors"
+ "net"
+ "net/http"
+ "net/url"
+ "strings"
+)
+
+type netDialerFunc func(network, addr string) (net.Conn, error)
+
+func (fn netDialerFunc) Dial(network, addr string) (net.Conn, error) {
+ return fn(network, addr)
+}
+
+func init() {
+ proxy_RegisterDialerType("http", func(proxyURL *url.URL, forwardDialer proxy_Dialer) (proxy_Dialer, error) {
+ return &httpProxyDialer{proxyURL: proxyURL, forwardDial: forwardDialer.Dial}, nil
+ })
+}
+
+type httpProxyDialer struct {
+ proxyURL *url.URL
+ forwardDial func(network, addr string) (net.Conn, error)
+}
+
+func (hpd *httpProxyDialer) Dial(network string, addr string) (net.Conn, error) {
+ hostPort, _ := hostPortNoPort(hpd.proxyURL)
+ conn, err := hpd.forwardDial(network, hostPort)
+ if err != nil {
+ return nil, err
+ }
+
+ connectHeader := make(http.Header)
+ if user := hpd.proxyURL.User; user != nil {
+ proxyUser := user.Username()
+ if proxyPassword, passwordSet := user.Password(); passwordSet {
+ credential := base64.StdEncoding.EncodeToString([]byte(proxyUser + ":" + proxyPassword))
+ connectHeader.Set("Proxy-Authorization", "Basic "+credential)
+ }
+ }
+
+ connectReq := &http.Request{
+ Method: "CONNECT",
+ URL: &url.URL{Opaque: addr},
+ Host: addr,
+ Header: connectHeader,
+ }
+
+ if err := connectReq.Write(conn); err != nil {
+ conn.Close()
+ return nil, err
+ }
+
+ // Read response. It's OK to use and discard buffered reader here becaue
+ // the remote server does not speak until spoken to.
+ br := bufio.NewReader(conn)
+ resp, err := http.ReadResponse(br, connectReq)
+ if err != nil {
+ conn.Close()
+ return nil, err
+ }
+
+ if resp.StatusCode != 200 {
+ conn.Close()
+ f := strings.SplitN(resp.Status, " ", 2)
+ return nil, errors.New(f[1])
+ }
+ return conn, nil
+}
diff --git a/vendor/github.com/gorilla/websocket/server.go b/vendor/github.com/gorilla/websocket/server.go
new file mode 100644
index 0000000000000..887d558918c72
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/server.go
@@ -0,0 +1,363 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "bufio"
+ "errors"
+ "io"
+ "net/http"
+ "net/url"
+ "strings"
+ "time"
+)
+
+// HandshakeError describes an error with the handshake from the peer.
+type HandshakeError struct {
+ message string
+}
+
+func (e HandshakeError) Error() string { return e.message }
+
+// Upgrader specifies parameters for upgrading an HTTP connection to a
+// WebSocket connection.
+type Upgrader struct {
+ // HandshakeTimeout specifies the duration for the handshake to complete.
+ HandshakeTimeout time.Duration
+
+ // ReadBufferSize and WriteBufferSize specify I/O buffer sizes in bytes. If a buffer
+ // size is zero, then buffers allocated by the HTTP server are used. The
+ // I/O buffer sizes do not limit the size of the messages that can be sent
+ // or received.
+ ReadBufferSize, WriteBufferSize int
+
+ // WriteBufferPool is a pool of buffers for write operations. If the value
+ // is not set, then write buffers are allocated to the connection for the
+ // lifetime of the connection.
+ //
+ // A pool is most useful when the application has a modest volume of writes
+ // across a large number of connections.
+ //
+ // Applications should use a single pool for each unique value of
+ // WriteBufferSize.
+ WriteBufferPool BufferPool
+
+ // Subprotocols specifies the server's supported protocols in order of
+ // preference. If this field is not nil, then the Upgrade method negotiates a
+ // subprotocol by selecting the first match in this list with a protocol
+ // requested by the client. If there's no match, then no protocol is
+ // negotiated (the Sec-Websocket-Protocol header is not included in the
+ // handshake response).
+ Subprotocols []string
+
+ // Error specifies the function for generating HTTP error responses. If Error
+ // is nil, then http.Error is used to generate the HTTP response.
+ Error func(w http.ResponseWriter, r *http.Request, status int, reason error)
+
+ // CheckOrigin returns true if the request Origin header is acceptable. If
+ // CheckOrigin is nil, then a safe default is used: return false if the
+ // Origin request header is present and the origin host is not equal to
+ // request Host header.
+ //
+ // A CheckOrigin function should carefully validate the request origin to
+ // prevent cross-site request forgery.
+ CheckOrigin func(r *http.Request) bool
+
+ // EnableCompression specify if the server should attempt to negotiate per
+ // message compression (RFC 7692). Setting this value to true does not
+ // guarantee that compression will be supported. Currently only "no context
+ // takeover" modes are supported.
+ EnableCompression bool
+}
+
+func (u *Upgrader) returnError(w http.ResponseWriter, r *http.Request, status int, reason string) (*Conn, error) {
+ err := HandshakeError{reason}
+ if u.Error != nil {
+ u.Error(w, r, status, err)
+ } else {
+ w.Header().Set("Sec-Websocket-Version", "13")
+ http.Error(w, http.StatusText(status), status)
+ }
+ return nil, err
+}
+
+// checkSameOrigin returns true if the origin is not set or is equal to the request host.
+func checkSameOrigin(r *http.Request) bool {
+ origin := r.Header["Origin"]
+ if len(origin) == 0 {
+ return true
+ }
+ u, err := url.Parse(origin[0])
+ if err != nil {
+ return false
+ }
+ return equalASCIIFold(u.Host, r.Host)
+}
+
+func (u *Upgrader) selectSubprotocol(r *http.Request, responseHeader http.Header) string {
+ if u.Subprotocols != nil {
+ clientProtocols := Subprotocols(r)
+ for _, serverProtocol := range u.Subprotocols {
+ for _, clientProtocol := range clientProtocols {
+ if clientProtocol == serverProtocol {
+ return clientProtocol
+ }
+ }
+ }
+ } else if responseHeader != nil {
+ return responseHeader.Get("Sec-Websocket-Protocol")
+ }
+ return ""
+}
+
+// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
+//
+// The responseHeader is included in the response to the client's upgrade
+// request. Use the responseHeader to specify cookies (Set-Cookie) and the
+// application negotiated subprotocol (Sec-WebSocket-Protocol).
+//
+// If the upgrade fails, then Upgrade replies to the client with an HTTP error
+// response.
+func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*Conn, error) {
+ const badHandshake = "websocket: the client is not using the websocket protocol: "
+
+ if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
+ return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'upgrade' token not found in 'Connection' header")
+ }
+
+ if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
+ return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'websocket' token not found in 'Upgrade' header")
+ }
+
+ if r.Method != "GET" {
+ return u.returnError(w, r, http.StatusMethodNotAllowed, badHandshake+"request method is not GET")
+ }
+
+ if !tokenListContainsValue(r.Header, "Sec-Websocket-Version", "13") {
+ return u.returnError(w, r, http.StatusBadRequest, "websocket: unsupported version: 13 not found in 'Sec-Websocket-Version' header")
+ }
+
+ if _, ok := responseHeader["Sec-Websocket-Extensions"]; ok {
+ return u.returnError(w, r, http.StatusInternalServerError, "websocket: application specific 'Sec-WebSocket-Extensions' headers are unsupported")
+ }
+
+ checkOrigin := u.CheckOrigin
+ if checkOrigin == nil {
+ checkOrigin = checkSameOrigin
+ }
+ if !checkOrigin(r) {
+ return u.returnError(w, r, http.StatusForbidden, "websocket: request origin not allowed by Upgrader.CheckOrigin")
+ }
+
+ challengeKey := r.Header.Get("Sec-Websocket-Key")
+ if challengeKey == "" {
+ return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'Sec-WebSocket-Key' header is missing or blank")
+ }
+
+ subprotocol := u.selectSubprotocol(r, responseHeader)
+
+ // Negotiate PMCE
+ var compress bool
+ if u.EnableCompression {
+ for _, ext := range parseExtensions(r.Header) {
+ if ext[""] != "permessage-deflate" {
+ continue
+ }
+ compress = true
+ break
+ }
+ }
+
+ h, ok := w.(http.Hijacker)
+ if !ok {
+ return u.returnError(w, r, http.StatusInternalServerError, "websocket: response does not implement http.Hijacker")
+ }
+ var brw *bufio.ReadWriter
+ netConn, brw, err := h.Hijack()
+ if err != nil {
+ return u.returnError(w, r, http.StatusInternalServerError, err.Error())
+ }
+
+ if brw.Reader.Buffered() > 0 {
+ netConn.Close()
+ return nil, errors.New("websocket: client sent data before handshake is complete")
+ }
+
+ var br *bufio.Reader
+ if u.ReadBufferSize == 0 && bufioReaderSize(netConn, brw.Reader) > 256 {
+ // Reuse hijacked buffered reader as connection reader.
+ br = brw.Reader
+ }
+
+ buf := bufioWriterBuffer(netConn, brw.Writer)
+
+ var writeBuf []byte
+ if u.WriteBufferPool == nil && u.WriteBufferSize == 0 && len(buf) >= maxFrameHeaderSize+256 {
+ // Reuse hijacked write buffer as connection buffer.
+ writeBuf = buf
+ }
+
+ c := newConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize, u.WriteBufferPool, br, writeBuf)
+ c.subprotocol = subprotocol
+
+ if compress {
+ c.newCompressionWriter = compressNoContextTakeover
+ c.newDecompressionReader = decompressNoContextTakeover
+ }
+
+ // Use larger of hijacked buffer and connection write buffer for header.
+ p := buf
+ if len(c.writeBuf) > len(p) {
+ p = c.writeBuf
+ }
+ p = p[:0]
+
+ p = append(p, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "...)
+ p = append(p, computeAcceptKey(challengeKey)...)
+ p = append(p, "\r\n"...)
+ if c.subprotocol != "" {
+ p = append(p, "Sec-WebSocket-Protocol: "...)
+ p = append(p, c.subprotocol...)
+ p = append(p, "\r\n"...)
+ }
+ if compress {
+ p = append(p, "Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover; client_no_context_takeover\r\n"...)
+ }
+ for k, vs := range responseHeader {
+ if k == "Sec-Websocket-Protocol" {
+ continue
+ }
+ for _, v := range vs {
+ p = append(p, k...)
+ p = append(p, ": "...)
+ for i := 0; i < len(v); i++ {
+ b := v[i]
+ if b <= 31 {
+ // prevent response splitting.
+ b = ' '
+ }
+ p = append(p, b)
+ }
+ p = append(p, "\r\n"...)
+ }
+ }
+ p = append(p, "\r\n"...)
+
+ // Clear deadlines set by HTTP server.
+ netConn.SetDeadline(time.Time{})
+
+ if u.HandshakeTimeout > 0 {
+ netConn.SetWriteDeadline(time.Now().Add(u.HandshakeTimeout))
+ }
+ if _, err = netConn.Write(p); err != nil {
+ netConn.Close()
+ return nil, err
+ }
+ if u.HandshakeTimeout > 0 {
+ netConn.SetWriteDeadline(time.Time{})
+ }
+
+ return c, nil
+}
+
+// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
+//
+// Deprecated: Use websocket.Upgrader instead.
+//
+// Upgrade does not perform origin checking. The application is responsible for
+// checking the Origin header before calling Upgrade. An example implementation
+// of the same origin policy check is:
+//
+// if req.Header.Get("Origin") != "http://"+req.Host {
+// http.Error(w, "Origin not allowed", http.StatusForbidden)
+// return
+// }
+//
+// If the endpoint supports subprotocols, then the application is responsible
+// for negotiating the protocol used on the connection. Use the Subprotocols()
+// function to get the subprotocols requested by the client. Use the
+// Sec-Websocket-Protocol response header to specify the subprotocol selected
+// by the application.
+//
+// The responseHeader is included in the response to the client's upgrade
+// request. Use the responseHeader to specify cookies (Set-Cookie) and the
+// negotiated subprotocol (Sec-Websocket-Protocol).
+//
+// The connection buffers IO to the underlying network connection. The
+// readBufSize and writeBufSize parameters specify the size of the buffers to
+// use. Messages can be larger than the buffers.
+//
+// If the request is not a valid WebSocket handshake, then Upgrade returns an
+// error of type HandshakeError. Applications should handle this error by
+// replying to the client with an HTTP error response.
+func Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header, readBufSize, writeBufSize int) (*Conn, error) {
+ u := Upgrader{ReadBufferSize: readBufSize, WriteBufferSize: writeBufSize}
+ u.Error = func(w http.ResponseWriter, r *http.Request, status int, reason error) {
+ // don't return errors to maintain backwards compatibility
+ }
+ u.CheckOrigin = func(r *http.Request) bool {
+ // allow all connections by default
+ return true
+ }
+ return u.Upgrade(w, r, responseHeader)
+}
+
+// Subprotocols returns the subprotocols requested by the client in the
+// Sec-Websocket-Protocol header.
+func Subprotocols(r *http.Request) []string {
+ h := strings.TrimSpace(r.Header.Get("Sec-Websocket-Protocol"))
+ if h == "" {
+ return nil
+ }
+ protocols := strings.Split(h, ",")
+ for i := range protocols {
+ protocols[i] = strings.TrimSpace(protocols[i])
+ }
+ return protocols
+}
+
+// IsWebSocketUpgrade returns true if the client requested upgrade to the
+// WebSocket protocol.
+func IsWebSocketUpgrade(r *http.Request) bool {
+ return tokenListContainsValue(r.Header, "Connection", "upgrade") &&
+ tokenListContainsValue(r.Header, "Upgrade", "websocket")
+}
+
+// bufioReaderSize size returns the size of a bufio.Reader.
+func bufioReaderSize(originalReader io.Reader, br *bufio.Reader) int {
+ // This code assumes that peek on a reset reader returns
+ // bufio.Reader.buf[:0].
+ // TODO: Use bufio.Reader.Size() after Go 1.10
+ br.Reset(originalReader)
+ if p, err := br.Peek(0); err == nil {
+ return cap(p)
+ }
+ return 0
+}
+
+// writeHook is an io.Writer that records the last slice passed to it vio
+// io.Writer.Write.
+type writeHook struct {
+ p []byte
+}
+
+func (wh *writeHook) Write(p []byte) (int, error) {
+ wh.p = p
+ return len(p), nil
+}
+
+// bufioWriterBuffer grabs the buffer from a bufio.Writer.
+func bufioWriterBuffer(originalWriter io.Writer, bw *bufio.Writer) []byte {
+ // This code assumes that bufio.Writer.buf[:1] is passed to the
+ // bufio.Writer's underlying writer.
+ var wh writeHook
+ bw.Reset(&wh)
+ bw.WriteByte(0)
+ bw.Flush()
+
+ bw.Reset(originalWriter)
+
+ return wh.p[:cap(wh.p)]
+}
diff --git a/vendor/github.com/gorilla/websocket/trace.go b/vendor/github.com/gorilla/websocket/trace.go
new file mode 100644
index 0000000000000..834f122a00dbe
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/trace.go
@@ -0,0 +1,19 @@
+// +build go1.8
+
+package websocket
+
+import (
+ "crypto/tls"
+ "net/http/httptrace"
+)
+
+func doHandshakeWithTrace(trace *httptrace.ClientTrace, tlsConn *tls.Conn, cfg *tls.Config) error {
+ if trace.TLSHandshakeStart != nil {
+ trace.TLSHandshakeStart()
+ }
+ err := doHandshake(tlsConn, cfg)
+ if trace.TLSHandshakeDone != nil {
+ trace.TLSHandshakeDone(tlsConn.ConnectionState(), err)
+ }
+ return err
+}
diff --git a/vendor/github.com/gorilla/websocket/trace_17.go b/vendor/github.com/gorilla/websocket/trace_17.go
new file mode 100644
index 0000000000000..77d05a0b5748c
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/trace_17.go
@@ -0,0 +1,12 @@
+// +build !go1.8
+
+package websocket
+
+import (
+ "crypto/tls"
+ "net/http/httptrace"
+)
+
+func doHandshakeWithTrace(trace *httptrace.ClientTrace, tlsConn *tls.Conn, cfg *tls.Config) error {
+ return doHandshake(tlsConn, cfg)
+}
diff --git a/vendor/github.com/gorilla/websocket/util.go b/vendor/github.com/gorilla/websocket/util.go
new file mode 100644
index 0000000000000..7bf2f66c6747d
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/util.go
@@ -0,0 +1,283 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package websocket
+
+import (
+ "crypto/rand"
+ "crypto/sha1"
+ "encoding/base64"
+ "io"
+ "net/http"
+ "strings"
+ "unicode/utf8"
+)
+
+var keyGUID = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
+
+func computeAcceptKey(challengeKey string) string {
+ h := sha1.New()
+ h.Write([]byte(challengeKey))
+ h.Write(keyGUID)
+ return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+func generateChallengeKey() (string, error) {
+ p := make([]byte, 16)
+ if _, err := io.ReadFull(rand.Reader, p); err != nil {
+ return "", err
+ }
+ return base64.StdEncoding.EncodeToString(p), nil
+}
+
+// Token octets per RFC 2616.
+var isTokenOctet = [256]bool{
+ '!': true,
+ '#': true,
+ '$': true,
+ '%': true,
+ '&': true,
+ '\'': true,
+ '*': true,
+ '+': true,
+ '-': true,
+ '.': true,
+ '0': true,
+ '1': true,
+ '2': true,
+ '3': true,
+ '4': true,
+ '5': true,
+ '6': true,
+ '7': true,
+ '8': true,
+ '9': true,
+ 'A': true,
+ 'B': true,
+ 'C': true,
+ 'D': true,
+ 'E': true,
+ 'F': true,
+ 'G': true,
+ 'H': true,
+ 'I': true,
+ 'J': true,
+ 'K': true,
+ 'L': true,
+ 'M': true,
+ 'N': true,
+ 'O': true,
+ 'P': true,
+ 'Q': true,
+ 'R': true,
+ 'S': true,
+ 'T': true,
+ 'U': true,
+ 'W': true,
+ 'V': true,
+ 'X': true,
+ 'Y': true,
+ 'Z': true,
+ '^': true,
+ '_': true,
+ '`': true,
+ 'a': true,
+ 'b': true,
+ 'c': true,
+ 'd': true,
+ 'e': true,
+ 'f': true,
+ 'g': true,
+ 'h': true,
+ 'i': true,
+ 'j': true,
+ 'k': true,
+ 'l': true,
+ 'm': true,
+ 'n': true,
+ 'o': true,
+ 'p': true,
+ 'q': true,
+ 'r': true,
+ 's': true,
+ 't': true,
+ 'u': true,
+ 'v': true,
+ 'w': true,
+ 'x': true,
+ 'y': true,
+ 'z': true,
+ '|': true,
+ '~': true,
+}
+
+// skipSpace returns a slice of the string s with all leading RFC 2616 linear
+// whitespace removed.
+func skipSpace(s string) (rest string) {
+ i := 0
+ for ; i < len(s); i++ {
+ if b := s[i]; b != ' ' && b != '\t' {
+ break
+ }
+ }
+ return s[i:]
+}
+
+// nextToken returns the leading RFC 2616 token of s and the string following
+// the token.
+func nextToken(s string) (token, rest string) {
+ i := 0
+ for ; i < len(s); i++ {
+ if !isTokenOctet[s[i]] {
+ break
+ }
+ }
+ return s[:i], s[i:]
+}
+
+// nextTokenOrQuoted returns the leading token or quoted string per RFC 2616
+// and the string following the token or quoted string.
+func nextTokenOrQuoted(s string) (value string, rest string) {
+ if !strings.HasPrefix(s, "\"") {
+ return nextToken(s)
+ }
+ s = s[1:]
+ for i := 0; i < len(s); i++ {
+ switch s[i] {
+ case '"':
+ return s[:i], s[i+1:]
+ case '\\':
+ p := make([]byte, len(s)-1)
+ j := copy(p, s[:i])
+ escape := true
+ for i = i + 1; i < len(s); i++ {
+ b := s[i]
+ switch {
+ case escape:
+ escape = false
+ p[j] = b
+ j++
+ case b == '\\':
+ escape = true
+ case b == '"':
+ return string(p[:j]), s[i+1:]
+ default:
+ p[j] = b
+ j++
+ }
+ }
+ return "", ""
+ }
+ }
+ return "", ""
+}
+
+// equalASCIIFold returns true if s is equal to t with ASCII case folding as
+// defined in RFC 4790.
+func equalASCIIFold(s, t string) bool {
+ for s != "" && t != "" {
+ sr, size := utf8.DecodeRuneInString(s)
+ s = s[size:]
+ tr, size := utf8.DecodeRuneInString(t)
+ t = t[size:]
+ if sr == tr {
+ continue
+ }
+ if 'A' <= sr && sr <= 'Z' {
+ sr = sr + 'a' - 'A'
+ }
+ if 'A' <= tr && tr <= 'Z' {
+ tr = tr + 'a' - 'A'
+ }
+ if sr != tr {
+ return false
+ }
+ }
+ return s == t
+}
+
+// tokenListContainsValue returns true if the 1#token header with the given
+// name contains a token equal to value with ASCII case folding.
+func tokenListContainsValue(header http.Header, name string, value string) bool {
+headers:
+ for _, s := range header[name] {
+ for {
+ var t string
+ t, s = nextToken(skipSpace(s))
+ if t == "" {
+ continue headers
+ }
+ s = skipSpace(s)
+ if s != "" && s[0] != ',' {
+ continue headers
+ }
+ if equalASCIIFold(t, value) {
+ return true
+ }
+ if s == "" {
+ continue headers
+ }
+ s = s[1:]
+ }
+ }
+ return false
+}
+
+// parseExtensions parses WebSocket extensions from a header.
+func parseExtensions(header http.Header) []map[string]string {
+ // From RFC 6455:
+ //
+ // Sec-WebSocket-Extensions = extension-list
+ // extension-list = 1#extension
+ // extension = extension-token *( ";" extension-param )
+ // extension-token = registered-token
+ // registered-token = token
+ // extension-param = token [ "=" (token | quoted-string) ]
+ // ;When using the quoted-string syntax variant, the value
+ // ;after quoted-string unescaping MUST conform to the
+ // ;'token' ABNF.
+
+ var result []map[string]string
+headers:
+ for _, s := range header["Sec-Websocket-Extensions"] {
+ for {
+ var t string
+ t, s = nextToken(skipSpace(s))
+ if t == "" {
+ continue headers
+ }
+ ext := map[string]string{"": t}
+ for {
+ s = skipSpace(s)
+ if !strings.HasPrefix(s, ";") {
+ break
+ }
+ var k string
+ k, s = nextToken(skipSpace(s[1:]))
+ if k == "" {
+ continue headers
+ }
+ s = skipSpace(s)
+ var v string
+ if strings.HasPrefix(s, "=") {
+ v, s = nextTokenOrQuoted(skipSpace(s[1:]))
+ s = skipSpace(s)
+ }
+ if s != "" && s[0] != ',' && s[0] != ';' {
+ continue headers
+ }
+ ext[k] = v
+ }
+ if s != "" && s[0] != ',' {
+ continue headers
+ }
+ result = append(result, ext)
+ if s == "" {
+ continue headers
+ }
+ s = s[1:]
+ }
+ }
+ return result
+}
diff --git a/vendor/github.com/gorilla/websocket/x_net_proxy.go b/vendor/github.com/gorilla/websocket/x_net_proxy.go
new file mode 100644
index 0000000000000..2e668f6b8821e
--- /dev/null
+++ b/vendor/github.com/gorilla/websocket/x_net_proxy.go
@@ -0,0 +1,473 @@
+// Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.
+//go:generate bundle -o x_net_proxy.go golang.org/x/net/proxy
+
+// Package proxy provides support for a variety of protocols to proxy network
+// data.
+//
+
+package websocket
+
+import (
+ "errors"
+ "io"
+ "net"
+ "net/url"
+ "os"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+type proxy_direct struct{}
+
+// Direct is a direct proxy: one that makes network connections directly.
+var proxy_Direct = proxy_direct{}
+
+func (proxy_direct) Dial(network, addr string) (net.Conn, error) {
+ return net.Dial(network, addr)
+}
+
+// A PerHost directs connections to a default Dialer unless the host name
+// requested matches one of a number of exceptions.
+type proxy_PerHost struct {
+ def, bypass proxy_Dialer
+
+ bypassNetworks []*net.IPNet
+ bypassIPs []net.IP
+ bypassZones []string
+ bypassHosts []string
+}
+
+// NewPerHost returns a PerHost Dialer that directs connections to either
+// defaultDialer or bypass, depending on whether the connection matches one of
+// the configured rules.
+func proxy_NewPerHost(defaultDialer, bypass proxy_Dialer) *proxy_PerHost {
+ return &proxy_PerHost{
+ def: defaultDialer,
+ bypass: bypass,
+ }
+}
+
+// Dial connects to the address addr on the given network through either
+// defaultDialer or bypass.
+func (p *proxy_PerHost) Dial(network, addr string) (c net.Conn, err error) {
+ host, _, err := net.SplitHostPort(addr)
+ if err != nil {
+ return nil, err
+ }
+
+ return p.dialerForRequest(host).Dial(network, addr)
+}
+
+func (p *proxy_PerHost) dialerForRequest(host string) proxy_Dialer {
+ if ip := net.ParseIP(host); ip != nil {
+ for _, net := range p.bypassNetworks {
+ if net.Contains(ip) {
+ return p.bypass
+ }
+ }
+ for _, bypassIP := range p.bypassIPs {
+ if bypassIP.Equal(ip) {
+ return p.bypass
+ }
+ }
+ return p.def
+ }
+
+ for _, zone := range p.bypassZones {
+ if strings.HasSuffix(host, zone) {
+ return p.bypass
+ }
+ if host == zone[1:] {
+ // For a zone ".example.com", we match "example.com"
+ // too.
+ return p.bypass
+ }
+ }
+ for _, bypassHost := range p.bypassHosts {
+ if bypassHost == host {
+ return p.bypass
+ }
+ }
+ return p.def
+}
+
+// AddFromString parses a string that contains comma-separated values
+// specifying hosts that should use the bypass proxy. Each value is either an
+// IP address, a CIDR range, a zone (*.example.com) or a host name
+// (localhost). A best effort is made to parse the string and errors are
+// ignored.
+func (p *proxy_PerHost) AddFromString(s string) {
+ hosts := strings.Split(s, ",")
+ for _, host := range hosts {
+ host = strings.TrimSpace(host)
+ if len(host) == 0 {
+ continue
+ }
+ if strings.Contains(host, "/") {
+ // We assume that it's a CIDR address like 127.0.0.0/8
+ if _, net, err := net.ParseCIDR(host); err == nil {
+ p.AddNetwork(net)
+ }
+ continue
+ }
+ if ip := net.ParseIP(host); ip != nil {
+ p.AddIP(ip)
+ continue
+ }
+ if strings.HasPrefix(host, "*.") {
+ p.AddZone(host[1:])
+ continue
+ }
+ p.AddHost(host)
+ }
+}
+
+// AddIP specifies an IP address that will use the bypass proxy. Note that
+// this will only take effect if a literal IP address is dialed. A connection
+// to a named host will never match an IP.
+func (p *proxy_PerHost) AddIP(ip net.IP) {
+ p.bypassIPs = append(p.bypassIPs, ip)
+}
+
+// AddNetwork specifies an IP range that will use the bypass proxy. Note that
+// this will only take effect if a literal IP address is dialed. A connection
+// to a named host will never match.
+func (p *proxy_PerHost) AddNetwork(net *net.IPNet) {
+ p.bypassNetworks = append(p.bypassNetworks, net)
+}
+
+// AddZone specifies a DNS suffix that will use the bypass proxy. A zone of
+// "example.com" matches "example.com" and all of its subdomains.
+func (p *proxy_PerHost) AddZone(zone string) {
+ if strings.HasSuffix(zone, ".") {
+ zone = zone[:len(zone)-1]
+ }
+ if !strings.HasPrefix(zone, ".") {
+ zone = "." + zone
+ }
+ p.bypassZones = append(p.bypassZones, zone)
+}
+
+// AddHost specifies a host name that will use the bypass proxy.
+func (p *proxy_PerHost) AddHost(host string) {
+ if strings.HasSuffix(host, ".") {
+ host = host[:len(host)-1]
+ }
+ p.bypassHosts = append(p.bypassHosts, host)
+}
+
+// A Dialer is a means to establish a connection.
+type proxy_Dialer interface {
+ // Dial connects to the given address via the proxy.
+ Dial(network, addr string) (c net.Conn, err error)
+}
+
+// Auth contains authentication parameters that specific Dialers may require.
+type proxy_Auth struct {
+ User, Password string
+}
+
+// FromEnvironment returns the dialer specified by the proxy related variables in
+// the environment.
+func proxy_FromEnvironment() proxy_Dialer {
+ allProxy := proxy_allProxyEnv.Get()
+ if len(allProxy) == 0 {
+ return proxy_Direct
+ }
+
+ proxyURL, err := url.Parse(allProxy)
+ if err != nil {
+ return proxy_Direct
+ }
+ proxy, err := proxy_FromURL(proxyURL, proxy_Direct)
+ if err != nil {
+ return proxy_Direct
+ }
+
+ noProxy := proxy_noProxyEnv.Get()
+ if len(noProxy) == 0 {
+ return proxy
+ }
+
+ perHost := proxy_NewPerHost(proxy, proxy_Direct)
+ perHost.AddFromString(noProxy)
+ return perHost
+}
+
+// proxySchemes is a map from URL schemes to a function that creates a Dialer
+// from a URL with such a scheme.
+var proxy_proxySchemes map[string]func(*url.URL, proxy_Dialer) (proxy_Dialer, error)
+
+// RegisterDialerType takes a URL scheme and a function to generate Dialers from
+// a URL with that scheme and a forwarding Dialer. Registered schemes are used
+// by FromURL.
+func proxy_RegisterDialerType(scheme string, f func(*url.URL, proxy_Dialer) (proxy_Dialer, error)) {
+ if proxy_proxySchemes == nil {
+ proxy_proxySchemes = make(map[string]func(*url.URL, proxy_Dialer) (proxy_Dialer, error))
+ }
+ proxy_proxySchemes[scheme] = f
+}
+
+// FromURL returns a Dialer given a URL specification and an underlying
+// Dialer for it to make network requests.
+func proxy_FromURL(u *url.URL, forward proxy_Dialer) (proxy_Dialer, error) {
+ var auth *proxy_Auth
+ if u.User != nil {
+ auth = new(proxy_Auth)
+ auth.User = u.User.Username()
+ if p, ok := u.User.Password(); ok {
+ auth.Password = p
+ }
+ }
+
+ switch u.Scheme {
+ case "socks5":
+ return proxy_SOCKS5("tcp", u.Host, auth, forward)
+ }
+
+ // If the scheme doesn't match any of the built-in schemes, see if it
+ // was registered by another package.
+ if proxy_proxySchemes != nil {
+ if f, ok := proxy_proxySchemes[u.Scheme]; ok {
+ return f(u, forward)
+ }
+ }
+
+ return nil, errors.New("proxy: unknown scheme: " + u.Scheme)
+}
+
+var (
+ proxy_allProxyEnv = &proxy_envOnce{
+ names: []string{"ALL_PROXY", "all_proxy"},
+ }
+ proxy_noProxyEnv = &proxy_envOnce{
+ names: []string{"NO_PROXY", "no_proxy"},
+ }
+)
+
+// envOnce looks up an environment variable (optionally by multiple
+// names) once. It mitigates expensive lookups on some platforms
+// (e.g. Windows).
+// (Borrowed from net/http/transport.go)
+type proxy_envOnce struct {
+ names []string
+ once sync.Once
+ val string
+}
+
+func (e *proxy_envOnce) Get() string {
+ e.once.Do(e.init)
+ return e.val
+}
+
+func (e *proxy_envOnce) init() {
+ for _, n := range e.names {
+ e.val = os.Getenv(n)
+ if e.val != "" {
+ return
+ }
+ }
+}
+
+// SOCKS5 returns a Dialer that makes SOCKSv5 connections to the given address
+// with an optional username and password. See RFC 1928 and RFC 1929.
+func proxy_SOCKS5(network, addr string, auth *proxy_Auth, forward proxy_Dialer) (proxy_Dialer, error) {
+ s := &proxy_socks5{
+ network: network,
+ addr: addr,
+ forward: forward,
+ }
+ if auth != nil {
+ s.user = auth.User
+ s.password = auth.Password
+ }
+
+ return s, nil
+}
+
+type proxy_socks5 struct {
+ user, password string
+ network, addr string
+ forward proxy_Dialer
+}
+
+const proxy_socks5Version = 5
+
+const (
+ proxy_socks5AuthNone = 0
+ proxy_socks5AuthPassword = 2
+)
+
+const proxy_socks5Connect = 1
+
+const (
+ proxy_socks5IP4 = 1
+ proxy_socks5Domain = 3
+ proxy_socks5IP6 = 4
+)
+
+var proxy_socks5Errors = []string{
+ "",
+ "general failure",
+ "connection forbidden",
+ "network unreachable",
+ "host unreachable",
+ "connection refused",
+ "TTL expired",
+ "command not supported",
+ "address type not supported",
+}
+
+// Dial connects to the address addr on the given network via the SOCKS5 proxy.
+func (s *proxy_socks5) Dial(network, addr string) (net.Conn, error) {
+ switch network {
+ case "tcp", "tcp6", "tcp4":
+ default:
+ return nil, errors.New("proxy: no support for SOCKS5 proxy connections of type " + network)
+ }
+
+ conn, err := s.forward.Dial(s.network, s.addr)
+ if err != nil {
+ return nil, err
+ }
+ if err := s.connect(conn, addr); err != nil {
+ conn.Close()
+ return nil, err
+ }
+ return conn, nil
+}
+
+// connect takes an existing connection to a socks5 proxy server,
+// and commands the server to extend that connection to target,
+// which must be a canonical address with a host and port.
+func (s *proxy_socks5) connect(conn net.Conn, target string) error {
+ host, portStr, err := net.SplitHostPort(target)
+ if err != nil {
+ return err
+ }
+
+ port, err := strconv.Atoi(portStr)
+ if err != nil {
+ return errors.New("proxy: failed to parse port number: " + portStr)
+ }
+ if port < 1 || port > 0xffff {
+ return errors.New("proxy: port number out of range: " + portStr)
+ }
+
+ // the size here is just an estimate
+ buf := make([]byte, 0, 6+len(host))
+
+ buf = append(buf, proxy_socks5Version)
+ if len(s.user) > 0 && len(s.user) < 256 && len(s.password) < 256 {
+ buf = append(buf, 2 /* num auth methods */, proxy_socks5AuthNone, proxy_socks5AuthPassword)
+ } else {
+ buf = append(buf, 1 /* num auth methods */, proxy_socks5AuthNone)
+ }
+
+ if _, err := conn.Write(buf); err != nil {
+ return errors.New("proxy: failed to write greeting to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+
+ if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+ return errors.New("proxy: failed to read greeting from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+ if buf[0] != 5 {
+ return errors.New("proxy: SOCKS5 proxy at " + s.addr + " has unexpected version " + strconv.Itoa(int(buf[0])))
+ }
+ if buf[1] == 0xff {
+ return errors.New("proxy: SOCKS5 proxy at " + s.addr + " requires authentication")
+ }
+
+ // See RFC 1929
+ if buf[1] == proxy_socks5AuthPassword {
+ buf = buf[:0]
+ buf = append(buf, 1 /* password protocol version */)
+ buf = append(buf, uint8(len(s.user)))
+ buf = append(buf, s.user...)
+ buf = append(buf, uint8(len(s.password)))
+ buf = append(buf, s.password...)
+
+ if _, err := conn.Write(buf); err != nil {
+ return errors.New("proxy: failed to write authentication request to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+
+ if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+ return errors.New("proxy: failed to read authentication reply from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+
+ if buf[1] != 0 {
+ return errors.New("proxy: SOCKS5 proxy at " + s.addr + " rejected username/password")
+ }
+ }
+
+ buf = buf[:0]
+ buf = append(buf, proxy_socks5Version, proxy_socks5Connect, 0 /* reserved */)
+
+ if ip := net.ParseIP(host); ip != nil {
+ if ip4 := ip.To4(); ip4 != nil {
+ buf = append(buf, proxy_socks5IP4)
+ ip = ip4
+ } else {
+ buf = append(buf, proxy_socks5IP6)
+ }
+ buf = append(buf, ip...)
+ } else {
+ if len(host) > 255 {
+ return errors.New("proxy: destination host name too long: " + host)
+ }
+ buf = append(buf, proxy_socks5Domain)
+ buf = append(buf, byte(len(host)))
+ buf = append(buf, host...)
+ }
+ buf = append(buf, byte(port>>8), byte(port))
+
+ if _, err := conn.Write(buf); err != nil {
+ return errors.New("proxy: failed to write connect request to SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+
+ if _, err := io.ReadFull(conn, buf[:4]); err != nil {
+ return errors.New("proxy: failed to read connect reply from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+
+ failure := "unknown error"
+ if int(buf[1]) < len(proxy_socks5Errors) {
+ failure = proxy_socks5Errors[buf[1]]
+ }
+
+ if len(failure) > 0 {
+ return errors.New("proxy: SOCKS5 proxy at " + s.addr + " failed to connect: " + failure)
+ }
+
+ bytesToDiscard := 0
+ switch buf[3] {
+ case proxy_socks5IP4:
+ bytesToDiscard = net.IPv4len
+ case proxy_socks5IP6:
+ bytesToDiscard = net.IPv6len
+ case proxy_socks5Domain:
+ _, err := io.ReadFull(conn, buf[:1])
+ if err != nil {
+ return errors.New("proxy: failed to read domain length from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+ bytesToDiscard = int(buf[0])
+ default:
+ return errors.New("proxy: got unknown address type " + strconv.Itoa(int(buf[3])) + " from SOCKS5 proxy at " + s.addr)
+ }
+
+ if cap(buf) < bytesToDiscard {
+ buf = make([]byte, bytesToDiscard)
+ } else {
+ buf = buf[:bytesToDiscard]
+ }
+ if _, err := io.ReadFull(conn, buf); err != nil {
+ return errors.New("proxy: failed to read address from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+
+ // Also need to discard the port number
+ if _, err := io.ReadFull(conn, buf[:2]); err != nil {
+ return errors.New("proxy: failed to read port from SOCKS5 proxy at " + s.addr + ": " + err.Error())
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/hashicorp/golang-lru/.gitignore b/vendor/github.com/hashicorp/golang-lru/.gitignore
new file mode 100644
index 0000000000000..836562412fe8a
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/.gitignore
@@ -0,0 +1,23 @@
+# 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
+*.test
diff --git a/vendor/github.com/hashicorp/golang-lru/2q.go b/vendor/github.com/hashicorp/golang-lru/2q.go
new file mode 100644
index 0000000000000..e474cd07581ac
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/2q.go
@@ -0,0 +1,223 @@
+package lru
+
+import (
+ "fmt"
+ "sync"
+
+ "github.com/hashicorp/golang-lru/simplelru"
+)
+
+const (
+ // Default2QRecentRatio is the ratio of the 2Q cache dedicated
+ // to recently added entries that have only been accessed once.
+ Default2QRecentRatio = 0.25
+
+ // Default2QGhostEntries is the default ratio of ghost
+ // entries kept to track entries recently evicted
+ Default2QGhostEntries = 0.50
+)
+
+// TwoQueueCache is a thread-safe fixed size 2Q cache.
+// 2Q is an enhancement over the standard LRU cache
+// in that it tracks both frequently and recently used
+// entries separately. This avoids a burst in access to new
+// entries from evicting frequently used entries. It adds some
+// additional tracking overhead to the standard LRU cache, and is
+// computationally about 2x the cost, and adds some metadata over
+// head. The ARCCache is similar, but does not require setting any
+// parameters.
+type TwoQueueCache struct {
+ size int
+ recentSize int
+
+ recent simplelru.LRUCache
+ frequent simplelru.LRUCache
+ recentEvict simplelru.LRUCache
+ lock sync.RWMutex
+}
+
+// New2Q creates a new TwoQueueCache using the default
+// values for the parameters.
+func New2Q(size int) (*TwoQueueCache, error) {
+ return New2QParams(size, Default2QRecentRatio, Default2QGhostEntries)
+}
+
+// New2QParams creates a new TwoQueueCache using the provided
+// parameter values.
+func New2QParams(size int, recentRatio float64, ghostRatio float64) (*TwoQueueCache, error) {
+ if size <= 0 {
+ return nil, fmt.Errorf("invalid size")
+ }
+ if recentRatio < 0.0 || recentRatio > 1.0 {
+ return nil, fmt.Errorf("invalid recent ratio")
+ }
+ if ghostRatio < 0.0 || ghostRatio > 1.0 {
+ return nil, fmt.Errorf("invalid ghost ratio")
+ }
+
+ // Determine the sub-sizes
+ recentSize := int(float64(size) * recentRatio)
+ evictSize := int(float64(size) * ghostRatio)
+
+ // Allocate the LRUs
+ recent, err := simplelru.NewLRU(size, nil)
+ if err != nil {
+ return nil, err
+ }
+ frequent, err := simplelru.NewLRU(size, nil)
+ if err != nil {
+ return nil, err
+ }
+ recentEvict, err := simplelru.NewLRU(evictSize, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ // Initialize the cache
+ c := &TwoQueueCache{
+ size: size,
+ recentSize: recentSize,
+ recent: recent,
+ frequent: frequent,
+ recentEvict: recentEvict,
+ }
+ return c, nil
+}
+
+// Get looks up a key's value from the cache.
+func (c *TwoQueueCache) Get(key interface{}) (value interface{}, ok bool) {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ // Check if this is a frequent value
+ if val, ok := c.frequent.Get(key); ok {
+ return val, ok
+ }
+
+ // If the value is contained in recent, then we
+ // promote it to frequent
+ if val, ok := c.recent.Peek(key); ok {
+ c.recent.Remove(key)
+ c.frequent.Add(key, val)
+ return val, ok
+ }
+
+ // No hit
+ return nil, false
+}
+
+// Add adds a value to the cache.
+func (c *TwoQueueCache) Add(key, value interface{}) {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ // Check if the value is frequently used already,
+ // and just update the value
+ if c.frequent.Contains(key) {
+ c.frequent.Add(key, value)
+ return
+ }
+
+ // Check if the value is recently used, and promote
+ // the value into the frequent list
+ if c.recent.Contains(key) {
+ c.recent.Remove(key)
+ c.frequent.Add(key, value)
+ return
+ }
+
+ // If the value was recently evicted, add it to the
+ // frequently used list
+ if c.recentEvict.Contains(key) {
+ c.ensureSpace(true)
+ c.recentEvict.Remove(key)
+ c.frequent.Add(key, value)
+ return
+ }
+
+ // Add to the recently seen list
+ c.ensureSpace(false)
+ c.recent.Add(key, value)
+ return
+}
+
+// ensureSpace is used to ensure we have space in the cache
+func (c *TwoQueueCache) ensureSpace(recentEvict bool) {
+ // If we have space, nothing to do
+ recentLen := c.recent.Len()
+ freqLen := c.frequent.Len()
+ if recentLen+freqLen < c.size {
+ return
+ }
+
+ // If the recent buffer is larger than
+ // the target, evict from there
+ if recentLen > 0 && (recentLen > c.recentSize || (recentLen == c.recentSize && !recentEvict)) {
+ k, _, _ := c.recent.RemoveOldest()
+ c.recentEvict.Add(k, nil)
+ return
+ }
+
+ // Remove from the frequent list otherwise
+ c.frequent.RemoveOldest()
+}
+
+// Len returns the number of items in the cache.
+func (c *TwoQueueCache) Len() int {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+ return c.recent.Len() + c.frequent.Len()
+}
+
+// Keys returns a slice of the keys in the cache.
+// The frequently used keys are first in the returned slice.
+func (c *TwoQueueCache) Keys() []interface{} {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+ k1 := c.frequent.Keys()
+ k2 := c.recent.Keys()
+ return append(k1, k2...)
+}
+
+// Remove removes the provided key from the cache.
+func (c *TwoQueueCache) Remove(key interface{}) {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+ if c.frequent.Remove(key) {
+ return
+ }
+ if c.recent.Remove(key) {
+ return
+ }
+ if c.recentEvict.Remove(key) {
+ return
+ }
+}
+
+// Purge is used to completely clear the cache.
+func (c *TwoQueueCache) Purge() {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+ c.recent.Purge()
+ c.frequent.Purge()
+ c.recentEvict.Purge()
+}
+
+// Contains is used to check if the cache contains a key
+// without updating recency or frequency.
+func (c *TwoQueueCache) Contains(key interface{}) bool {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+ return c.frequent.Contains(key) || c.recent.Contains(key)
+}
+
+// Peek is used to inspect the cache value of a key
+// without updating recency or frequency.
+func (c *TwoQueueCache) Peek(key interface{}) (value interface{}, ok bool) {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+ if val, ok := c.frequent.Peek(key); ok {
+ return val, ok
+ }
+ return c.recent.Peek(key)
+}
diff --git a/vendor/github.com/hashicorp/golang-lru/LICENSE b/vendor/github.com/hashicorp/golang-lru/LICENSE
new file mode 100644
index 0000000000000..be2cc4dfb609f
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/LICENSE
@@ -0,0 +1,362 @@
+Mozilla Public License, version 2.0
+
+1. Definitions
+
+1.1. "Contributor"
+
+ means each individual or legal entity that creates, contributes to the
+ creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+
+ means the combination of the Contributions of others (if any) used by a
+ Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+
+ means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+
+ means Source Code Form to which the initial Contributor has attached the
+ notice in Exhibit A, the Executable Form of such Source Code Form, and
+ Modifications of such Source Code Form, in each case including portions
+ thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+ means
+
+ a. that the initial Contributor has attached the notice described in
+ Exhibit B to the Covered Software; or
+
+ b. that the Covered Software was made available under the terms of
+ version 1.1 or earlier of the License, but not also under the terms of
+ a Secondary License.
+
+1.6. "Executable Form"
+
+ means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+
+ means a work that combines Covered Software with other material, in a
+ separate file or files, that is not Covered Software.
+
+1.8. "License"
+
+ means this document.
+
+1.9. "Licensable"
+
+ means having the right to grant, to the maximum extent possible, whether
+ at the time of the initial grant or subsequently, any and all of the
+ rights conveyed by this License.
+
+1.10. "Modifications"
+
+ means any of the following:
+
+ a. any file in Source Code Form that results from an addition to,
+ deletion from, or modification of the contents of Covered Software; or
+
+ b. any new file in Source Code Form that contains any Covered Software.
+
+1.11. "Patent Claims" of a Contributor
+
+ means any patent claim(s), including without limitation, method,
+ process, and apparatus claims, in any patent Licensable by such
+ Contributor that would be infringed, but for the grant of the License,
+ by the making, using, selling, offering for sale, having made, import,
+ or transfer of either its Contributions or its Contributor Version.
+
+1.12. "Secondary License"
+
+ means either the GNU General Public License, Version 2.0, the GNU Lesser
+ General Public License, Version 2.1, the GNU Affero General Public
+ License, Version 3.0, or any later versions of those licenses.
+
+1.13. "Source Code Form"
+
+ means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+
+ means an individual or a legal entity exercising rights under this
+ License. For legal entities, "You" includes any entity that controls, is
+ controlled by, or is under common control with You. For purposes of this
+ definition, "control" means (a) the power, direct or indirect, to cause
+ the direction or management of such entity, whether by contract or
+ otherwise, or (b) ownership of more than fifty percent (50%) of the
+ outstanding shares or beneficial ownership of such entity.
+
+
+2. License Grants and Conditions
+
+2.1. Grants
+
+ Each Contributor hereby grants You a world-wide, royalty-free,
+ non-exclusive license:
+
+ a. under intellectual property rights (other than patent or trademark)
+ Licensable by such Contributor to use, reproduce, make available,
+ modify, display, perform, distribute, and otherwise exploit its
+ Contributions, either on an unmodified basis, with Modifications, or
+ as part of a Larger Work; and
+
+ b. under Patent Claims of such Contributor to make, use, sell, offer for
+ sale, have made, import, and otherwise transfer either its
+ Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+ The licenses granted in Section 2.1 with respect to any Contribution
+ become effective for each Contribution on the date the Contributor first
+ distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+ The licenses granted in this Section 2 are the only rights granted under
+ this License. No additional rights or licenses will be implied from the
+ distribution or licensing of Covered Software under this License.
+ Notwithstanding Section 2.1(b) above, no patent license is granted by a
+ Contributor:
+
+ a. for any code that a Contributor has removed from Covered Software; or
+
+ b. for infringements caused by: (i) Your and any other third party's
+ modifications of Covered Software, or (ii) the combination of its
+ Contributions with other software (except as part of its Contributor
+ Version); or
+
+ c. under Patent Claims infringed by Covered Software in the absence of
+ its Contributions.
+
+ This License does not grant any rights in the trademarks, service marks,
+ or logos of any Contributor (except as may be necessary to comply with
+ the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+ No Contributor makes additional grants as a result of Your choice to
+ distribute the Covered Software under a subsequent version of this
+ License (see Section 10.2) or under the terms of a Secondary License (if
+ permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+ Each Contributor represents that the Contributor believes its
+ Contributions are its original creation(s) or it has sufficient rights to
+ grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+ This License is not intended to limit any rights You have under
+ applicable copyright doctrines of fair use, fair dealing, or other
+ equivalents.
+
+2.7. Conditions
+
+ Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
+ Section 2.1.
+
+
+3. Responsibilities
+
+3.1. Distribution of Source Form
+
+ All distribution of Covered Software in Source Code Form, including any
+ Modifications that You create or to which You contribute, must be under
+ the terms of this License. You must inform recipients that the Source
+ Code Form of the Covered Software is governed by the terms of this
+ License, and how they can obtain a copy of this License. You may not
+ attempt to alter or restrict the recipients' rights in the Source Code
+ Form.
+
+3.2. Distribution of Executable Form
+
+ If You distribute Covered Software in Executable Form then:
+
+ a. such Covered Software must also be made available in Source Code Form,
+ as described in Section 3.1, and You must inform recipients of the
+ Executable Form how they can obtain a copy of such Source Code Form by
+ reasonable means in a timely manner, at a charge no more than the cost
+ of distribution to the recipient; and
+
+ b. You may distribute such Executable Form under the terms of this
+ License, or sublicense it under different terms, provided that the
+ license for the Executable Form does not attempt to limit or alter the
+ recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+ You may create and distribute a Larger Work under terms of Your choice,
+ provided that You also comply with the requirements of this License for
+ the Covered Software. If the Larger Work is a combination of Covered
+ Software with a work governed by one or more Secondary Licenses, and the
+ Covered Software is not Incompatible With Secondary Licenses, this
+ License permits You to additionally distribute such Covered Software
+ under the terms of such Secondary License(s), so that the recipient of
+ the Larger Work may, at their option, further distribute the Covered
+ Software under the terms of either this License or such Secondary
+ License(s).
+
+3.4. Notices
+
+ You may not remove or alter the substance of any license notices
+ (including copyright notices, patent notices, disclaimers of warranty, or
+ limitations of liability) contained within the Source Code Form of the
+ Covered Software, except that You may alter any license notices to the
+ extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+ You may choose to offer, and to charge a fee for, warranty, support,
+ indemnity or liability obligations to one or more recipients of Covered
+ Software. However, You may do so only on Your own behalf, and not on
+ behalf of any Contributor. You must make it absolutely clear that any
+ such warranty, support, indemnity, or liability obligation is offered by
+ You alone, and You hereby agree to indemnify every Contributor for any
+ liability incurred by such Contributor as a result of warranty, support,
+ indemnity or liability terms You offer. You may include additional
+ disclaimers of warranty and limitations of liability specific to any
+ jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+ If it is impossible for You to comply with any of the terms of this License
+ with respect to some or all of the Covered Software due to statute,
+ judicial order, or regulation then You must: (a) comply with the terms of
+ this License to the maximum extent possible; and (b) describe the
+ limitations and the code they affect. Such description must be placed in a
+ text file included with all distributions of the Covered Software under
+ this License. Except to the extent prohibited by statute or regulation,
+ such description must be sufficiently detailed for a recipient of ordinary
+ skill to be able to understand it.
+
+5. Termination
+
+5.1. The rights granted under this License will terminate automatically if You
+ fail to comply with any of its terms. However, if You become compliant,
+ then the rights granted under this License from a particular Contributor
+ are reinstated (a) provisionally, unless and until such Contributor
+ explicitly and finally terminates Your grants, and (b) on an ongoing
+ basis, if such Contributor fails to notify You of the non-compliance by
+ some reasonable means prior to 60 days after You have come back into
+ compliance. Moreover, Your grants from a particular Contributor are
+ reinstated on an ongoing basis if such Contributor notifies You of the
+ non-compliance by some reasonable means, this is the first time You have
+ received notice of non-compliance with this License from such
+ Contributor, and You become compliant prior to 30 days after Your receipt
+ of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+ infringement claim (excluding declaratory judgment actions,
+ counter-claims, and cross-claims) alleging that a Contributor Version
+ directly or indirectly infringes any patent, then the rights granted to
+ You by any and all Contributors for the Covered Software under Section
+ 2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
+ license agreements (excluding distributors and resellers) which have been
+ validly granted by You or Your distributors under this License prior to
+ termination shall survive termination.
+
+6. Disclaimer of Warranty
+
+ Covered Software is provided under this License on an "as is" basis,
+ without warranty of any kind, either expressed, implied, or statutory,
+ including, without limitation, warranties that the Covered Software is free
+ of defects, merchantable, fit for a particular purpose or non-infringing.
+ The entire risk as to the quality and performance of the Covered Software
+ is with You. Should any Covered Software prove defective in any respect,
+ You (not any Contributor) assume the cost of any necessary servicing,
+ repair, or correction. This disclaimer of warranty constitutes an essential
+ part of this License. No use of any Covered Software is authorized under
+ this License except under this disclaimer.
+
+7. Limitation of Liability
+
+ Under no circumstances and under no legal theory, whether tort (including
+ negligence), contract, or otherwise, shall any Contributor, or anyone who
+ distributes Covered Software as permitted above, be liable to You for any
+ direct, indirect, special, incidental, or consequential damages of any
+ character including, without limitation, damages for lost profits, loss of
+ goodwill, work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses, even if such party shall have been
+ informed of the possibility of such damages. This limitation of liability
+ shall not apply to liability for death or personal injury resulting from
+ such party's negligence to the extent applicable law prohibits such
+ limitation. Some jurisdictions do not allow the exclusion or limitation of
+ incidental or consequential damages, so this exclusion and limitation may
+ not apply to You.
+
+8. Litigation
+
+ Any litigation relating to this License may be brought only in the courts
+ of a jurisdiction where the defendant maintains its principal place of
+ business and such litigation shall be governed by laws of that
+ jurisdiction, without reference to its conflict-of-law provisions. Nothing
+ in this Section shall prevent a party's ability to bring cross-claims or
+ counter-claims.
+
+9. Miscellaneous
+
+ This License represents the complete agreement concerning the subject
+ matter hereof. If any provision of this License is held to be
+ unenforceable, such provision shall be reformed only to the extent
+ necessary to make it enforceable. Any law or regulation which provides that
+ the language of a contract shall be construed against the drafter shall not
+ be used to construe this License against a Contributor.
+
+
+10. Versions of the License
+
+10.1. New Versions
+
+ Mozilla Foundation is the license steward. Except as provided in Section
+ 10.3, no one other than the license steward has the right to modify or
+ publish new versions of this License. Each version will be given a
+ distinguishing version number.
+
+10.2. Effect of New Versions
+
+ You may distribute the Covered Software under the terms of the version
+ of the License under which You originally received the Covered Software,
+ or under the terms of any subsequent version published by the license
+ steward.
+
+10.3. Modified Versions
+
+ If you create software not governed by this License, and you want to
+ create a new license for such software, you may create and use a
+ modified version of this License if you rename the license and remove
+ any references to the name of the license steward (except to note that
+ such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+ Licenses If You choose to distribute Source Code Form that is
+ Incompatible With Secondary Licenses under the terms of this version of
+ the License, the notice described in Exhibit B of this License must be
+ attached.
+
+Exhibit A - Source Code Form License Notice
+
+ This Source Code Form is subject to the
+ terms of the Mozilla Public License, v.
+ 2.0. If a copy of the MPL was not
+ distributed with this file, You can
+ obtain one at
+ http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular file,
+then You may include the notice in a location (such as a LICENSE file in a
+relevant directory) where a recipient would be likely to look for such a
+notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+
+ This Source Code Form is "Incompatible
+ With Secondary Licenses", as defined by
+ the Mozilla Public License, v. 2.0.
diff --git a/vendor/github.com/hashicorp/golang-lru/README.md b/vendor/github.com/hashicorp/golang-lru/README.md
new file mode 100644
index 0000000000000..33e58cfaf97ea
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/README.md
@@ -0,0 +1,25 @@
+golang-lru
+==========
+
+This provides the `lru` package which implements a fixed-size
+thread safe LRU cache. It is based on the cache in Groupcache.
+
+Documentation
+=============
+
+Full docs are available on [Godoc](http://godoc.org/github.com/hashicorp/golang-lru)
+
+Example
+=======
+
+Using the LRU is very simple:
+
+```go
+l, _ := New(128)
+for i := 0; i < 256; i++ {
+ l.Add(i, nil)
+}
+if l.Len() != 128 {
+ panic(fmt.Sprintf("bad len: %v", l.Len()))
+}
+```
diff --git a/vendor/github.com/hashicorp/golang-lru/arc.go b/vendor/github.com/hashicorp/golang-lru/arc.go
new file mode 100644
index 0000000000000..555225a218c96
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/arc.go
@@ -0,0 +1,257 @@
+package lru
+
+import (
+ "sync"
+
+ "github.com/hashicorp/golang-lru/simplelru"
+)
+
+// ARCCache is a thread-safe fixed size Adaptive Replacement Cache (ARC).
+// ARC is an enhancement over the standard LRU cache in that tracks both
+// frequency and recency of use. This avoids a burst in access to new
+// entries from evicting the frequently used older entries. It adds some
+// additional tracking overhead to a standard LRU cache, computationally
+// it is roughly 2x the cost, and the extra memory overhead is linear
+// with the size of the cache. ARC has been patented by IBM, but is
+// similar to the TwoQueueCache (2Q) which requires setting parameters.
+type ARCCache struct {
+ size int // Size is the total capacity of the cache
+ p int // P is the dynamic preference towards T1 or T2
+
+ t1 simplelru.LRUCache // T1 is the LRU for recently accessed items
+ b1 simplelru.LRUCache // B1 is the LRU for evictions from t1
+
+ t2 simplelru.LRUCache // T2 is the LRU for frequently accessed items
+ b2 simplelru.LRUCache // B2 is the LRU for evictions from t2
+
+ lock sync.RWMutex
+}
+
+// NewARC creates an ARC of the given size
+func NewARC(size int) (*ARCCache, error) {
+ // Create the sub LRUs
+ b1, err := simplelru.NewLRU(size, nil)
+ if err != nil {
+ return nil, err
+ }
+ b2, err := simplelru.NewLRU(size, nil)
+ if err != nil {
+ return nil, err
+ }
+ t1, err := simplelru.NewLRU(size, nil)
+ if err != nil {
+ return nil, err
+ }
+ t2, err := simplelru.NewLRU(size, nil)
+ if err != nil {
+ return nil, err
+ }
+
+ // Initialize the ARC
+ c := &ARCCache{
+ size: size,
+ p: 0,
+ t1: t1,
+ b1: b1,
+ t2: t2,
+ b2: b2,
+ }
+ return c, nil
+}
+
+// Get looks up a key's value from the cache.
+func (c *ARCCache) Get(key interface{}) (value interface{}, ok bool) {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ // If the value is contained in T1 (recent), then
+ // promote it to T2 (frequent)
+ if val, ok := c.t1.Peek(key); ok {
+ c.t1.Remove(key)
+ c.t2.Add(key, val)
+ return val, ok
+ }
+
+ // Check if the value is contained in T2 (frequent)
+ if val, ok := c.t2.Get(key); ok {
+ return val, ok
+ }
+
+ // No hit
+ return nil, false
+}
+
+// Add adds a value to the cache.
+func (c *ARCCache) Add(key, value interface{}) {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ // Check if the value is contained in T1 (recent), and potentially
+ // promote it to frequent T2
+ if c.t1.Contains(key) {
+ c.t1.Remove(key)
+ c.t2.Add(key, value)
+ return
+ }
+
+ // Check if the value is already in T2 (frequent) and update it
+ if c.t2.Contains(key) {
+ c.t2.Add(key, value)
+ return
+ }
+
+ // Check if this value was recently evicted as part of the
+ // recently used list
+ if c.b1.Contains(key) {
+ // T1 set is too small, increase P appropriately
+ delta := 1
+ b1Len := c.b1.Len()
+ b2Len := c.b2.Len()
+ if b2Len > b1Len {
+ delta = b2Len / b1Len
+ }
+ if c.p+delta >= c.size {
+ c.p = c.size
+ } else {
+ c.p += delta
+ }
+
+ // Potentially need to make room in the cache
+ if c.t1.Len()+c.t2.Len() >= c.size {
+ c.replace(false)
+ }
+
+ // Remove from B1
+ c.b1.Remove(key)
+
+ // Add the key to the frequently used list
+ c.t2.Add(key, value)
+ return
+ }
+
+ // Check if this value was recently evicted as part of the
+ // frequently used list
+ if c.b2.Contains(key) {
+ // T2 set is too small, decrease P appropriately
+ delta := 1
+ b1Len := c.b1.Len()
+ b2Len := c.b2.Len()
+ if b1Len > b2Len {
+ delta = b1Len / b2Len
+ }
+ if delta >= c.p {
+ c.p = 0
+ } else {
+ c.p -= delta
+ }
+
+ // Potentially need to make room in the cache
+ if c.t1.Len()+c.t2.Len() >= c.size {
+ c.replace(true)
+ }
+
+ // Remove from B2
+ c.b2.Remove(key)
+
+ // Add the key to the frequently used list
+ c.t2.Add(key, value)
+ return
+ }
+
+ // Potentially need to make room in the cache
+ if c.t1.Len()+c.t2.Len() >= c.size {
+ c.replace(false)
+ }
+
+ // Keep the size of the ghost buffers trim
+ if c.b1.Len() > c.size-c.p {
+ c.b1.RemoveOldest()
+ }
+ if c.b2.Len() > c.p {
+ c.b2.RemoveOldest()
+ }
+
+ // Add to the recently seen list
+ c.t1.Add(key, value)
+ return
+}
+
+// replace is used to adaptively evict from either T1 or T2
+// based on the current learned value of P
+func (c *ARCCache) replace(b2ContainsKey bool) {
+ t1Len := c.t1.Len()
+ if t1Len > 0 && (t1Len > c.p || (t1Len == c.p && b2ContainsKey)) {
+ k, _, ok := c.t1.RemoveOldest()
+ if ok {
+ c.b1.Add(k, nil)
+ }
+ } else {
+ k, _, ok := c.t2.RemoveOldest()
+ if ok {
+ c.b2.Add(k, nil)
+ }
+ }
+}
+
+// Len returns the number of cached entries
+func (c *ARCCache) Len() int {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+ return c.t1.Len() + c.t2.Len()
+}
+
+// Keys returns all the cached keys
+func (c *ARCCache) Keys() []interface{} {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+ k1 := c.t1.Keys()
+ k2 := c.t2.Keys()
+ return append(k1, k2...)
+}
+
+// Remove is used to purge a key from the cache
+func (c *ARCCache) Remove(key interface{}) {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+ if c.t1.Remove(key) {
+ return
+ }
+ if c.t2.Remove(key) {
+ return
+ }
+ if c.b1.Remove(key) {
+ return
+ }
+ if c.b2.Remove(key) {
+ return
+ }
+}
+
+// Purge is used to clear the cache
+func (c *ARCCache) Purge() {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+ c.t1.Purge()
+ c.t2.Purge()
+ c.b1.Purge()
+ c.b2.Purge()
+}
+
+// Contains is used to check if the cache contains a key
+// without updating recency or frequency.
+func (c *ARCCache) Contains(key interface{}) bool {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+ return c.t1.Contains(key) || c.t2.Contains(key)
+}
+
+// Peek is used to inspect the cache value of a key
+// without updating recency or frequency.
+func (c *ARCCache) Peek(key interface{}) (value interface{}, ok bool) {
+ c.lock.RLock()
+ defer c.lock.RUnlock()
+ if val, ok := c.t1.Peek(key); ok {
+ return val, ok
+ }
+ return c.t2.Peek(key)
+}
diff --git a/vendor/github.com/hashicorp/golang-lru/doc.go b/vendor/github.com/hashicorp/golang-lru/doc.go
new file mode 100644
index 0000000000000..2547df979d0ba
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/doc.go
@@ -0,0 +1,21 @@
+// Package lru provides three different LRU caches of varying sophistication.
+//
+// Cache is a simple LRU cache. It is based on the
+// LRU implementation in groupcache:
+// https://github.com/golang/groupcache/tree/master/lru
+//
+// TwoQueueCache tracks frequently used and recently used entries separately.
+// This avoids a burst of accesses from taking out frequently used entries,
+// at the cost of about 2x computational overhead and some extra bookkeeping.
+//
+// ARCCache is an adaptive replacement cache. It tracks recent evictions as
+// well as recent usage in both the frequent and recent caches. Its
+// computational overhead is comparable to TwoQueueCache, but the memory
+// overhead is linear with the size of the cache.
+//
+// ARC has been patented by IBM, so do not use it if that is problematic for
+// your program.
+//
+// All caches in this package take locks while operating, and are therefore
+// thread-safe for consumers.
+package lru
diff --git a/vendor/github.com/hashicorp/golang-lru/go.mod b/vendor/github.com/hashicorp/golang-lru/go.mod
new file mode 100644
index 0000000000000..824cb97e8346d
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/go.mod
@@ -0,0 +1 @@
+module github.com/hashicorp/golang-lru
diff --git a/vendor/github.com/hashicorp/golang-lru/lru.go b/vendor/github.com/hashicorp/golang-lru/lru.go
new file mode 100644
index 0000000000000..1cbe04b7d0fc0
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/lru.go
@@ -0,0 +1,116 @@
+package lru
+
+import (
+ "sync"
+
+ "github.com/hashicorp/golang-lru/simplelru"
+)
+
+// Cache is a thread-safe fixed size LRU cache.
+type Cache struct {
+ lru simplelru.LRUCache
+ lock sync.RWMutex
+}
+
+// New creates an LRU of the given size.
+func New(size int) (*Cache, error) {
+ return NewWithEvict(size, nil)
+}
+
+// NewWithEvict constructs a fixed size cache with the given eviction
+// callback.
+func NewWithEvict(size int, onEvicted func(key interface{}, value interface{})) (*Cache, error) {
+ lru, err := simplelru.NewLRU(size, simplelru.EvictCallback(onEvicted))
+ if err != nil {
+ return nil, err
+ }
+ c := &Cache{
+ lru: lru,
+ }
+ return c, nil
+}
+
+// Purge is used to completely clear the cache.
+func (c *Cache) Purge() {
+ c.lock.Lock()
+ c.lru.Purge()
+ c.lock.Unlock()
+}
+
+// Add adds a value to the cache. Returns true if an eviction occurred.
+func (c *Cache) Add(key, value interface{}) (evicted bool) {
+ c.lock.Lock()
+ evicted = c.lru.Add(key, value)
+ c.lock.Unlock()
+ return evicted
+}
+
+// Get looks up a key's value from the cache.
+func (c *Cache) Get(key interface{}) (value interface{}, ok bool) {
+ c.lock.Lock()
+ value, ok = c.lru.Get(key)
+ c.lock.Unlock()
+ return value, ok
+}
+
+// Contains checks if a key is in the cache, without updating the
+// recent-ness or deleting it for being stale.
+func (c *Cache) Contains(key interface{}) bool {
+ c.lock.RLock()
+ containKey := c.lru.Contains(key)
+ c.lock.RUnlock()
+ return containKey
+}
+
+// Peek returns the key value (or undefined if not found) without updating
+// the "recently used"-ness of the key.
+func (c *Cache) Peek(key interface{}) (value interface{}, ok bool) {
+ c.lock.RLock()
+ value, ok = c.lru.Peek(key)
+ c.lock.RUnlock()
+ return value, ok
+}
+
+// ContainsOrAdd checks if a key is in the cache without updating the
+// recent-ness or deleting it for being stale, and if not, adds the value.
+// Returns whether found and whether an eviction occurred.
+func (c *Cache) ContainsOrAdd(key, value interface{}) (ok, evicted bool) {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ if c.lru.Contains(key) {
+ return true, false
+ }
+ evicted = c.lru.Add(key, value)
+ return false, evicted
+}
+
+// Remove removes the provided key from the cache.
+func (c *Cache) Remove(key interface{}) {
+ c.lock.Lock()
+ c.lru.Remove(key)
+ c.lock.Unlock()
+}
+
+// RemoveOldest removes the oldest item from the cache.
+func (c *Cache) RemoveOldest() {
+ c.lock.Lock()
+ c.lru.RemoveOldest()
+ c.lock.Unlock()
+}
+
+// Keys returns a slice of the keys in the cache, from oldest to newest.
+func (c *Cache) Keys() []interface{} {
+ c.lock.RLock()
+ keys := c.lru.Keys()
+ c.lock.RUnlock()
+ return keys
+}
+
+// Len returns the number of items in the cache.
+func (c *Cache) Len() int {
+ c.lock.RLock()
+ length := c.lru.Len()
+ c.lock.RUnlock()
+ return length
+}
diff --git a/vendor/github.com/hashicorp/golang-lru/simplelru/lru.go b/vendor/github.com/hashicorp/golang-lru/simplelru/lru.go
new file mode 100644
index 0000000000000..5673773b22beb
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/simplelru/lru.go
@@ -0,0 +1,161 @@
+package simplelru
+
+import (
+ "container/list"
+ "errors"
+)
+
+// EvictCallback is used to get a callback when a cache entry is evicted
+type EvictCallback func(key interface{}, value interface{})
+
+// LRU implements a non-thread safe fixed size LRU cache
+type LRU struct {
+ size int
+ evictList *list.List
+ items map[interface{}]*list.Element
+ onEvict EvictCallback
+}
+
+// entry is used to hold a value in the evictList
+type entry struct {
+ key interface{}
+ value interface{}
+}
+
+// NewLRU constructs an LRU of the given size
+func NewLRU(size int, onEvict EvictCallback) (*LRU, error) {
+ if size <= 0 {
+ return nil, errors.New("Must provide a positive size")
+ }
+ c := &LRU{
+ size: size,
+ evictList: list.New(),
+ items: make(map[interface{}]*list.Element),
+ onEvict: onEvict,
+ }
+ return c, nil
+}
+
+// Purge is used to completely clear the cache.
+func (c *LRU) Purge() {
+ for k, v := range c.items {
+ if c.onEvict != nil {
+ c.onEvict(k, v.Value.(*entry).value)
+ }
+ delete(c.items, k)
+ }
+ c.evictList.Init()
+}
+
+// Add adds a value to the cache. Returns true if an eviction occurred.
+func (c *LRU) Add(key, value interface{}) (evicted bool) {
+ // Check for existing item
+ if ent, ok := c.items[key]; ok {
+ c.evictList.MoveToFront(ent)
+ ent.Value.(*entry).value = value
+ return false
+ }
+
+ // Add new item
+ ent := &entry{key, value}
+ entry := c.evictList.PushFront(ent)
+ c.items[key] = entry
+
+ evict := c.evictList.Len() > c.size
+ // Verify size not exceeded
+ if evict {
+ c.removeOldest()
+ }
+ return evict
+}
+
+// Get looks up a key's value from the cache.
+func (c *LRU) Get(key interface{}) (value interface{}, ok bool) {
+ if ent, ok := c.items[key]; ok {
+ c.evictList.MoveToFront(ent)
+ return ent.Value.(*entry).value, true
+ }
+ return
+}
+
+// Contains checks if a key is in the cache, without updating the recent-ness
+// or deleting it for being stale.
+func (c *LRU) Contains(key interface{}) (ok bool) {
+ _, ok = c.items[key]
+ return ok
+}
+
+// Peek returns the key value (or undefined if not found) without updating
+// the "recently used"-ness of the key.
+func (c *LRU) Peek(key interface{}) (value interface{}, ok bool) {
+ var ent *list.Element
+ if ent, ok = c.items[key]; ok {
+ return ent.Value.(*entry).value, true
+ }
+ return nil, ok
+}
+
+// Remove removes the provided key from the cache, returning if the
+// key was contained.
+func (c *LRU) Remove(key interface{}) (present bool) {
+ if ent, ok := c.items[key]; ok {
+ c.removeElement(ent)
+ return true
+ }
+ return false
+}
+
+// RemoveOldest removes the oldest item from the cache.
+func (c *LRU) RemoveOldest() (key interface{}, value interface{}, ok bool) {
+ ent := c.evictList.Back()
+ if ent != nil {
+ c.removeElement(ent)
+ kv := ent.Value.(*entry)
+ return kv.key, kv.value, true
+ }
+ return nil, nil, false
+}
+
+// GetOldest returns the oldest entry
+func (c *LRU) GetOldest() (key interface{}, value interface{}, ok bool) {
+ ent := c.evictList.Back()
+ if ent != nil {
+ kv := ent.Value.(*entry)
+ return kv.key, kv.value, true
+ }
+ return nil, nil, false
+}
+
+// Keys returns a slice of the keys in the cache, from oldest to newest.
+func (c *LRU) Keys() []interface{} {
+ keys := make([]interface{}, len(c.items))
+ i := 0
+ for ent := c.evictList.Back(); ent != nil; ent = ent.Prev() {
+ keys[i] = ent.Value.(*entry).key
+ i++
+ }
+ return keys
+}
+
+// Len returns the number of items in the cache.
+func (c *LRU) Len() int {
+ return c.evictList.Len()
+}
+
+// removeOldest removes the oldest item from the cache.
+func (c *LRU) removeOldest() {
+ ent := c.evictList.Back()
+ if ent != nil {
+ c.removeElement(ent)
+ }
+}
+
+// removeElement is used to remove a given list element from the cache
+func (c *LRU) removeElement(e *list.Element) {
+ c.evictList.Remove(e)
+ kv := e.Value.(*entry)
+ delete(c.items, kv.key)
+ if c.onEvict != nil {
+ c.onEvict(kv.key, kv.value)
+ }
+}
diff --git a/vendor/github.com/hashicorp/golang-lru/simplelru/lru_interface.go b/vendor/github.com/hashicorp/golang-lru/simplelru/lru_interface.go
new file mode 100644
index 0000000000000..74c7077440c91
--- /dev/null
+++ b/vendor/github.com/hashicorp/golang-lru/simplelru/lru_interface.go
@@ -0,0 +1,36 @@
+package simplelru
+
+// LRUCache is the interface for simple LRU cache.
+type LRUCache interface {
+ // Adds a value to the cache, returns true if an eviction occurred and
+ // updates the "recently used"-ness of the key.
+ Add(key, value interface{}) bool
+
+ // Returns key's value from the cache and
+ // updates the "recently used"-ness of the key. #value, isFound
+ Get(key interface{}) (value interface{}, ok bool)
+
+ // Check if a key exsists in cache without updating the recent-ness.
+ Contains(key interface{}) (ok bool)
+
+ // Returns key's value without updating the "recently used"-ness of the key.
+ Peek(key interface{}) (value interface{}, ok bool)
+
+ // Removes a key from the cache.
+ Remove(key interface{}) bool
+
+ // Removes the oldest entry from cache.
+ RemoveOldest() (interface{}, interface{}, bool)
+
+ // Returns the oldest entry from the cache. #key, value, isFound
+ GetOldest() (interface{}, interface{}, bool)
+
+ // Returns a slice of the keys in the cache, from oldest to newest.
+ Keys() []interface{}
+
+ // Returns the number of items in the cache.
+ Len() int
+
+ // Clear all cache entries
+ Purge()
+}
diff --git a/vendor/github.com/matryer/moq/.gitignore b/vendor/github.com/matryer/moq/.gitignore
new file mode 100644
index 0000000000000..b15784e0c8603
--- /dev/null
+++ b/vendor/github.com/matryer/moq/.gitignore
@@ -0,0 +1,25 @@
+# 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
+*.test
+*.prof
+.vscode
diff --git a/vendor/github.com/matryer/moq/.travis.yml b/vendor/github.com/matryer/moq/.travis.yml
new file mode 100644
index 0000000000000..1bcf6df608478
--- /dev/null
+++ b/vendor/github.com/matryer/moq/.travis.yml
@@ -0,0 +1,23 @@
+language: go
+
+sudo: false
+
+branches:
+ only:
+ - master
+
+go:
+ - 1.11.x
+ - 1.12.x
+ - 1.13.x
+ - tip
+
+before_install:
+ - go get golang.org/x/lint/golint
+
+before_script:
+ - go vet ./...
+ - golint ./...
+
+script:
+ - go test -v ./...
diff --git a/vendor/github.com/matryer/moq/LICENSE b/vendor/github.com/matryer/moq/LICENSE
new file mode 100644
index 0000000000000..157d9d25d0e98
--- /dev/null
+++ b/vendor/github.com/matryer/moq/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Mat Ryer and David Hernandez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/matryer/moq/README.md b/vendor/github.com/matryer/moq/README.md
new file mode 100644
index 0000000000000..5327c44e9871a
--- /dev/null
+++ b/vendor/github.com/matryer/moq/README.md
@@ -0,0 +1,110 @@
+ [](https://travis-ci.org/matryer/moq) [](https://goreportcard.com/report/github.com/matryer/moq)
+
+Interface mocking tool for go generate.
+
+By [Mat Ryer](https://twitter.com/matryer) and [David Hernandez](https://github.com/dahernan), with ideas lovingly stolen from [Ernesto Jimenez](https://github.com/ernesto-jimenez).
+
+### What is Moq?
+
+Moq is a tool that generates a struct from any interface. The struct can be used in test code as a mock of the interface.
+
+
+
+above: Moq generates the code on the right.
+
+You can read more in the [Meet Moq blog post](http://bit.ly/meetmoq).
+
+### Installing
+
+To start using Moq, just run go get:
+```
+$ go get github.com/matryer/moq
+```
+
+### Usage
+
+```
+moq [flags] destination interface [interface2 [interface3 [...]]]
+ -out string
+ output file (default stdout)
+ -pkg string
+ package name (default will infer)
+Specifying an alias for the mock is also supported with the format 'interface:alias'
+Ex: moq -pkg different . MyInterface:MyMock
+```
+
+In a command line:
+
+```
+$ moq -out mocks_test.go . MyInterface
+```
+
+In code (for go generate):
+
+```go
+package my
+
+//go:generate moq -out myinterface_moq_test.go . MyInterface
+
+type MyInterface interface {
+ Method1() error
+ Method2(i int)
+}
+```
+
+Then run `go generate` for your package.
+
+### How to use it
+
+Mocking interfaces is a nice way to write unit tests where you can easily control the behaviour of the mocked object.
+
+Moq creates a struct that has a function field for each method, which you can declare in your test code.
+
+In this example, Moq generated the `EmailSenderMock` type:
+
+```go
+func TestCompleteSignup(t *testing.T) {
+
+ var sentTo string
+
+ mockedEmailSender = &EmailSenderMock{
+ SendFunc: func(to, subject, body string) error {
+ sentTo = to
+ return nil
+ },
+ }
+
+ CompleteSignUp("me@email.com", mockedEmailSender)
+
+ callsToSend := len(mockedEmailSender.SendCalls())
+ if callsToSend != 1 {
+ t.Errorf("Send was called %d times", callsToSend)
+ }
+ if sentTo != "me@email.com" {
+ t.Errorf("unexpected recipient: %s", sentTo)
+ }
+
+}
+
+func CompleteSignUp(to string, sender EmailSender) {
+ // TODO: this
+}
+```
+
+The mocked structure implements the interface, where each method calls the associated function field.
+
+## Tips
+
+* Keep mocked logic inside the test that is using it
+* Only mock the fields you need
+* It will panic if a nil function gets called
+* Name arguments in the interface for a better experience
+* Use closured variables inside your test function to capture details about the calls to the methods
+* Use `.MethodCalls()` to track the calls
+* Use `go:generate` to invoke the `moq` command
+
+## License
+
+The Moq project (and all code) is licensed under the [MIT License](LICENSE).
+
+The Moq logo was created by [Chris Ryer](http://chrisryer.co.uk) and is licensed under the [Creative Commons Attribution 3.0 License](https://creativecommons.org/licenses/by/3.0/).
diff --git a/vendor/github.com/matryer/moq/main.go b/vendor/github.com/matryer/moq/main.go
new file mode 100644
index 0000000000000..cd246cc8fb815
--- /dev/null
+++ b/vendor/github.com/matryer/moq/main.go
@@ -0,0 +1,77 @@
+package main
+
+import (
+ "bytes"
+ "errors"
+ "flag"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+
+ "github.com/matryer/moq/pkg/moq"
+)
+
+type userFlags struct {
+ outFile string
+ pkgName string
+ args []string
+}
+
+func main() {
+ var flags userFlags
+ flag.StringVar(&flags.outFile, "out", "", "output file (default stdout)")
+ flag.StringVar(&flags.pkgName, "pkg", "", "package name (default will infer)")
+
+ flag.Usage = func() {
+ fmt.Println(`moq [flags] destination interface [interface2 [interface3 [...]]]`)
+ flag.PrintDefaults()
+ fmt.Println(`Specifying an alias for the mock is also supported with the format 'interface:alias'`)
+ fmt.Println(`Ex: moq -pkg different . MyInterface:MyMock`)
+ }
+
+ flag.Parse()
+ flags.args = flag.Args()
+
+ if err := run(flags); err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ flag.Usage()
+ os.Exit(1)
+ }
+}
+
+func run(flags userFlags) error {
+ if len(flags.args) < 2 {
+ return errors.New("not enough arguments")
+ }
+
+ var buf bytes.Buffer
+ var out io.Writer = os.Stdout
+ if flags.outFile != "" {
+ out = &buf
+ }
+
+ destination := flags.args[0]
+ args := flags.args[1:]
+ m, err := moq.New(destination, flags.pkgName)
+ if err != nil {
+ return err
+ }
+
+ if err = m.Mock(out, args...); err != nil {
+ return err
+ }
+
+ if flags.outFile == "" {
+ return nil
+ }
+
+ // create the file
+ err = os.MkdirAll(filepath.Dir(flags.outFile), 0755)
+ if err != nil {
+ return err
+ }
+
+ return ioutil.WriteFile(flags.outFile, buf.Bytes(), 0644)
+}
diff --git a/vendor/github.com/matryer/moq/moq-logo-small.png b/vendor/github.com/matryer/moq/moq-logo-small.png
new file mode 100644
index 0000000000000..7a71c177ec9f4
Binary files /dev/null and b/vendor/github.com/matryer/moq/moq-logo-small.png differ
diff --git a/vendor/github.com/matryer/moq/moq-logo.png b/vendor/github.com/matryer/moq/moq-logo.png
new file mode 100644
index 0000000000000..7eae08f6f4df0
Binary files /dev/null and b/vendor/github.com/matryer/moq/moq-logo.png differ
diff --git a/vendor/github.com/matryer/moq/pkg/moq/moq.go b/vendor/github.com/matryer/moq/pkg/moq/moq.go
new file mode 100644
index 0000000000000..971c9421e1492
--- /dev/null
+++ b/vendor/github.com/matryer/moq/pkg/moq/moq.go
@@ -0,0 +1,372 @@
+package moq
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "go/format"
+ "go/types"
+ "io"
+ "os"
+ "path"
+ "path/filepath"
+ "strings"
+ "text/template"
+
+ "golang.org/x/tools/go/packages"
+)
+
+// This list comes from the golint codebase. Golint will complain about any of
+// these being mixed-case, like "Id" instead of "ID".
+var golintInitialisms = []string{
+ "ACL",
+ "API",
+ "ASCII",
+ "CPU",
+ "CSS",
+ "DNS",
+ "EOF",
+ "GUID",
+ "HTML",
+ "HTTP",
+ "HTTPS",
+ "ID",
+ "IP",
+ "JSON",
+ "LHS",
+ "QPS",
+ "RAM",
+ "RHS",
+ "RPC",
+ "SLA",
+ "SMTP",
+ "SQL",
+ "SSH",
+ "TCP",
+ "TLS",
+ "TTL",
+ "UDP",
+ "UI",
+ "UID",
+ "UUID",
+ "URI",
+ "URL",
+ "UTF8",
+ "VM",
+ "XML",
+ "XMPP",
+ "XSRF",
+ "XSS",
+}
+
+// Mocker can generate mock structs.
+type Mocker struct {
+ srcPkg *packages.Package
+ tmpl *template.Template
+ pkgName string
+ pkgPath string
+
+ imports map[string]bool
+}
+
+// New makes a new Mocker for the specified package directory.
+func New(src, packageName string) (*Mocker, error) {
+ srcPkg, err := pkgInfoFromPath(src, packages.LoadSyntax)
+ if err != nil {
+ return nil, fmt.Errorf("couldn't load source package: %s", err)
+ }
+ pkgPath, err := findPkgPath(packageName, srcPkg)
+ if err != nil {
+ return nil, fmt.Errorf("couldn't load mock package: %s", err)
+ }
+
+ tmpl, err := template.New("moq").Funcs(templateFuncs).Parse(moqTemplate)
+ if err != nil {
+ return nil, err
+ }
+ return &Mocker{
+ tmpl: tmpl,
+ srcPkg: srcPkg,
+ pkgName: preventZeroStr(packageName, srcPkg.Name),
+ pkgPath: pkgPath,
+ imports: make(map[string]bool),
+ }, nil
+}
+
+func preventZeroStr(val, defaultVal string) string {
+ if val == "" {
+ return defaultVal
+ }
+ return val
+}
+
+func findPkgPath(pkgInputVal string, srcPkg *packages.Package) (string, error) {
+ if pkgInputVal == "" {
+ return srcPkg.PkgPath, nil
+ }
+ if pkgInDir(".", pkgInputVal) {
+ return ".", nil
+ }
+ if pkgInDir(srcPkg.PkgPath, pkgInputVal) {
+ return srcPkg.PkgPath, nil
+ }
+ subdirectoryPath := filepath.Join(srcPkg.PkgPath, pkgInputVal)
+ if pkgInDir(subdirectoryPath, pkgInputVal) {
+ return subdirectoryPath, nil
+ }
+ return "", nil
+}
+
+func pkgInDir(pkgName, dir string) bool {
+ currentPkg, err := pkgInfoFromPath(dir, packages.LoadFiles)
+ if err != nil {
+ return false
+ }
+ return currentPkg.Name == pkgName || currentPkg.Name+"_test" == pkgName
+}
+
+// Mock generates a mock for the specified interface name.
+func (m *Mocker) Mock(w io.Writer, names ...string) error {
+ if len(names) == 0 {
+ return errors.New("must specify one interface")
+ }
+
+ doc := doc{
+ PackageName: m.pkgName,
+ Imports: moqImports,
+ }
+
+ mocksMethods := false
+
+ tpkg := m.srcPkg.Types
+ for _, name := range names {
+ n, mockName := parseInterfaceName(name)
+ iface := tpkg.Scope().Lookup(n)
+ if iface == nil {
+ return fmt.Errorf("cannot find interface %s", n)
+ }
+ if !types.IsInterface(iface.Type()) {
+ return fmt.Errorf("%s (%s) not an interface", n, iface.Type().String())
+ }
+ iiface := iface.Type().Underlying().(*types.Interface).Complete()
+ obj := obj{
+ InterfaceName: n,
+ MockName: mockName,
+ }
+ for i := 0; i < iiface.NumMethods(); i++ {
+ mocksMethods = true
+ meth := iiface.Method(i)
+ sig := meth.Type().(*types.Signature)
+ method := &method{
+ Name: meth.Name(),
+ }
+ obj.Methods = append(obj.Methods, method)
+ method.Params = m.extractArgs(sig, sig.Params(), "in%d")
+ method.Returns = m.extractArgs(sig, sig.Results(), "out%d")
+ }
+ doc.Objects = append(doc.Objects, obj)
+ }
+
+ if mocksMethods {
+ doc.Imports = append(doc.Imports, "sync")
+ }
+
+ for pkgToImport := range m.imports {
+ doc.Imports = append(doc.Imports, stripVendorPath(pkgToImport))
+ }
+
+ if tpkg.Name() != m.pkgName {
+ doc.SourcePackagePrefix = tpkg.Name() + "."
+ doc.Imports = append(doc.Imports, tpkg.Path())
+ }
+
+ var buf bytes.Buffer
+ err := m.tmpl.Execute(&buf, doc)
+ if err != nil {
+ return err
+ }
+ formatted, err := format.Source(buf.Bytes())
+ if err != nil {
+ return fmt.Errorf("go/format: %s", err)
+ }
+ if _, err := w.Write(formatted); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *Mocker) packageQualifier(pkg *types.Package) string {
+ if m.pkgPath != "" && m.pkgPath == pkg.Path() {
+ return ""
+ }
+ path := pkg.Path()
+ if pkg.Path() == "." {
+ wd, err := os.Getwd()
+ if err == nil {
+ path = stripGopath(wd)
+ }
+ }
+ m.imports[path] = true
+ return pkg.Name()
+}
+
+func (m *Mocker) extractArgs(sig *types.Signature, list *types.Tuple, nameFormat string) []*param {
+ var params []*param
+ listLen := list.Len()
+ for ii := 0; ii < listLen; ii++ {
+ p := list.At(ii)
+ name := p.Name()
+ if name == "" {
+ name = fmt.Sprintf(nameFormat, ii+1)
+ }
+ typename := types.TypeString(p.Type(), m.packageQualifier)
+ // check for final variadic argument
+ variadic := sig.Variadic() && ii == listLen-1 && typename[0:2] == "[]"
+ param := ¶m{
+ Name: name,
+ Type: typename,
+ Variadic: variadic,
+ }
+ params = append(params, param)
+ }
+ return params
+}
+
+func pkgInfoFromPath(src string, mode packages.LoadMode) (*packages.Package, error) {
+ conf := packages.Config{
+ Mode: mode,
+ Dir: src,
+ }
+ pkgs, err := packages.Load(&conf)
+ if err != nil {
+ return nil, err
+ }
+ if len(pkgs) == 0 {
+ return nil, errors.New("No packages found")
+ }
+ if len(pkgs) > 1 {
+ return nil, errors.New("More than one package was found")
+ }
+ return pkgs[0], nil
+}
+
+func parseInterfaceName(name string) (ifaceName, mockName string) {
+ parts := strings.SplitN(name, ":", 2)
+ ifaceName = parts[0]
+ mockName = ifaceName + "Mock"
+ if len(parts) == 2 {
+ mockName = parts[1]
+ }
+ return
+}
+
+type doc struct {
+ PackageName string
+ SourcePackagePrefix string
+ Objects []obj
+ Imports []string
+}
+
+type obj struct {
+ InterfaceName string
+ MockName string
+ Methods []*method
+}
+type method struct {
+ Name string
+ Params []*param
+ Returns []*param
+}
+
+func (m *method) Arglist() string {
+ params := make([]string, len(m.Params))
+ for i, p := range m.Params {
+ params[i] = p.String()
+ }
+ return strings.Join(params, ", ")
+}
+
+func (m *method) ArgCallList() string {
+ params := make([]string, len(m.Params))
+ for i, p := range m.Params {
+ params[i] = p.CallName()
+ }
+ return strings.Join(params, ", ")
+}
+
+func (m *method) ReturnArglist() string {
+ params := make([]string, len(m.Returns))
+ for i, p := range m.Returns {
+ params[i] = p.TypeString()
+ }
+ if len(m.Returns) > 1 {
+ return fmt.Sprintf("(%s)", strings.Join(params, ", "))
+ }
+ return strings.Join(params, ", ")
+}
+
+type param struct {
+ Name string
+ Type string
+ Variadic bool
+}
+
+func (p param) String() string {
+ return fmt.Sprintf("%s %s", p.Name, p.TypeString())
+}
+
+func (p param) CallName() string {
+ if p.Variadic {
+ return p.Name + "..."
+ }
+ return p.Name
+}
+
+func (p param) TypeString() string {
+ if p.Variadic {
+ return "..." + p.Type[2:]
+ }
+ return p.Type
+}
+
+var templateFuncs = template.FuncMap{
+ "Exported": func(s string) string {
+ if s == "" {
+ return ""
+ }
+ for _, initialism := range golintInitialisms {
+ if strings.ToUpper(s) == initialism {
+ return initialism
+ }
+ }
+ return strings.ToUpper(s[0:1]) + s[1:]
+ },
+}
+
+// stripVendorPath strips the vendor dir prefix from a package path.
+// For example we might encounter an absolute path like
+// github.com/foo/bar/vendor/github.com/pkg/errors which is resolved
+// to github.com/pkg/errors.
+func stripVendorPath(p string) string {
+ parts := strings.Split(p, "/vendor/")
+ if len(parts) == 1 {
+ return p
+ }
+ return strings.TrimLeft(path.Join(parts[1:]...), "/")
+}
+
+// stripGopath takes the directory to a package and remove the gopath to get the
+// canonical package name.
+//
+// taken from https://github.com/ernesto-jimenez/gogen
+// Copyright (c) 2015 Ernesto Jiménez
+func stripGopath(p string) string {
+ for _, gopath := range gopaths() {
+ p = strings.TrimPrefix(p, path.Join(gopath, "src")+"/")
+ }
+ return p
+}
+
+func gopaths() []string {
+ return strings.Split(os.Getenv("GOPATH"), string(filepath.ListSeparator))
+}
diff --git a/vendor/github.com/matryer/moq/pkg/moq/template.go b/vendor/github.com/matryer/moq/pkg/moq/template.go
new file mode 100644
index 0000000000000..bc33de236bfff
--- /dev/null
+++ b/vendor/github.com/matryer/moq/pkg/moq/template.go
@@ -0,0 +1,107 @@
+package moq
+
+// moqImports are the imports all moq files get.
+var moqImports = []string{}
+
+// moqTemplate is the template for mocked code.
+var moqTemplate = `// Code generated by moq; DO NOT EDIT.
+// github.com/matryer/moq
+
+package {{.PackageName}}
+{{- $sourcePackagePrefix := .SourcePackagePrefix}}
+
+import (
+{{- range .Imports }}
+ "{{.}}"
+{{- end }}
+)
+
+{{ range $i, $obj := .Objects -}}
+var (
+{{- range .Methods }}
+ lock{{$obj.MockName}}{{.Name}} sync.RWMutex
+{{- end }}
+)
+
+// Ensure, that {{.MockName}} does implement {{$sourcePackagePrefix}}{{.InterfaceName}}.
+// If this is not the case, regenerate this file with moq.
+var _ {{$sourcePackagePrefix}}{{.InterfaceName}} = &{{.MockName}}{}
+
+// {{.MockName}} is a mock implementation of {{$sourcePackagePrefix}}{{.InterfaceName}}.
+//
+// func TestSomethingThatUses{{.InterfaceName}}(t *testing.T) {
+//
+// // make and configure a mocked {{$sourcePackagePrefix}}{{.InterfaceName}}
+// mocked{{.InterfaceName}} := &{{.MockName}}{ {{ range .Methods }}
+// {{.Name}}Func: func({{ .Arglist }}) {{.ReturnArglist}} {
+// panic("mock out the {{.Name}} method")
+// },{{- end }}
+// }
+//
+// // use mocked{{.InterfaceName}} in code that requires {{$sourcePackagePrefix}}{{.InterfaceName}}
+// // and then make assertions.
+//
+// }
+type {{.MockName}} struct {
+{{- range .Methods }}
+ // {{.Name}}Func mocks the {{.Name}} method.
+ {{.Name}}Func func({{ .Arglist }}) {{.ReturnArglist}}
+{{ end }}
+ // calls tracks calls to the methods.
+ calls struct {
+{{- range .Methods }}
+ // {{ .Name }} holds details about calls to the {{.Name}} method.
+ {{ .Name }} []struct {
+ {{- range .Params }}
+ // {{ .Name | Exported }} is the {{ .Name }} argument value.
+ {{ .Name | Exported }} {{ .Type }}
+ {{- end }}
+ }
+{{- end }}
+ }
+}
+{{ range .Methods }}
+// {{.Name}} calls {{.Name}}Func.
+func (mock *{{$obj.MockName}}) {{.Name}}({{.Arglist}}) {{.ReturnArglist}} {
+ if mock.{{.Name}}Func == nil {
+ panic("{{$obj.MockName}}.{{.Name}}Func: method is nil but {{$obj.InterfaceName}}.{{.Name}} was just called")
+ }
+ callInfo := struct {
+ {{- range .Params }}
+ {{ .Name | Exported }} {{ .Type }}
+ {{- end }}
+ }{
+ {{- range .Params }}
+ {{ .Name | Exported }}: {{ .Name }},
+ {{- end }}
+ }
+ lock{{$obj.MockName}}{{.Name}}.Lock()
+ mock.calls.{{.Name}} = append(mock.calls.{{.Name}}, callInfo)
+ lock{{$obj.MockName}}{{.Name}}.Unlock()
+{{- if .ReturnArglist }}
+ return mock.{{.Name}}Func({{.ArgCallList}})
+{{- else }}
+ mock.{{.Name}}Func({{.ArgCallList}})
+{{- end }}
+}
+
+// {{.Name}}Calls gets all the calls that were made to {{.Name}}.
+// Check the length with:
+// len(mocked{{$obj.InterfaceName}}.{{.Name}}Calls())
+func (mock *{{$obj.MockName}}) {{.Name}}Calls() []struct {
+ {{- range .Params }}
+ {{ .Name | Exported }} {{ .Type }}
+ {{- end }}
+ } {
+ var calls []struct {
+ {{- range .Params }}
+ {{ .Name | Exported }} {{ .Type }}
+ {{- end }}
+ }
+ lock{{$obj.MockName}}{{.Name}}.RLock()
+ calls = mock.calls.{{.Name}}
+ lock{{$obj.MockName}}{{.Name}}.RUnlock()
+ return calls
+}
+{{ end -}}
+{{ end -}}`
diff --git a/vendor/github.com/matryer/moq/preview.png b/vendor/github.com/matryer/moq/preview.png
new file mode 100644
index 0000000000000..8fa7a627479e4
Binary files /dev/null and b/vendor/github.com/matryer/moq/preview.png differ
diff --git a/vendor/github.com/urfave/cli/v2/.flake8 b/vendor/github.com/urfave/cli/v2/.flake8
new file mode 100644
index 0000000000000..6deafc261704e
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/.flake8
@@ -0,0 +1,2 @@
+[flake8]
+max-line-length = 120
diff --git a/vendor/github.com/urfave/cli/v2/.gitignore b/vendor/github.com/urfave/cli/v2/.gitignore
new file mode 100644
index 0000000000000..b013e4ac68899
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/.gitignore
@@ -0,0 +1,5 @@
+*.coverprofile
+*.orig
+node_modules/
+vendor
+.idea
diff --git a/vendor/github.com/urfave/cli/v2/CODE_OF_CONDUCT.md b/vendor/github.com/urfave/cli/v2/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000000..41ba294f6db46
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/CODE_OF_CONDUCT.md
@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting Dan Buch at dan@meatballhat.com. All complaints will be
+reviewed and investigated and will result in a response that is deemed necessary
+and appropriate to the circumstances. The project team is obligated to maintain
+confidentiality with regard to the reporter of an incident. Further details of
+specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
diff --git a/vendor/github.com/urfave/cli/v2/LICENSE b/vendor/github.com/urfave/cli/v2/LICENSE
new file mode 100644
index 0000000000000..42a597e29bbb8
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Jeremy Saenz & Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/urfave/cli/v2/README.md b/vendor/github.com/urfave/cli/v2/README.md
new file mode 100644
index 0000000000000..e7fb3d7551a3f
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/README.md
@@ -0,0 +1,68 @@
+cli
+===
+
+[](https://ci.appveyor.com/project/urfave/cli)
+
+[](https://godoc.org/github.com/urfave/cli)
+[](https://codebeat.co/projects/github.1485827954.workers.dev-urfave-cli)
+[](https://goreportcard.com/report/urfave/cli)
+[](https://codecov.io/gh/urfave/cli)
+
+cli is a simple, fast, and fun package for building command line apps in Go. The
+goal is to enable developers to write fast and distributable command line
+applications in an expressive way.
+
+## Usage Documentation
+
+Usage documentation exists for each major version. Don't know what version you're on? You're probably using the version from the `master` branch, which is currently `v2`.
+
+- `v2` - [./docs/v2/manual.md](./docs/v2/manual.md)
+- `v1` - [./docs/v1/manual.md](./docs/v1/manual.md)
+
+## Installation
+
+Make sure you have a working Go environment. Go version 1.11+ is supported. [See the install instructions for Go](http://golang.org/doc/install.html).
+
+Go Modules are strongly recommended when using this package. [See the go blog guide on using Go Modules](https://blog.golang.org/using-go-modules).
+
+### Using `v2` releases
+
+```
+$ GO111MODULE=on go get github.com/urfave/cli/v2
+```
+
+```go
+...
+import (
+ "github.com/urfave/cli/v2" // imports as package "cli"
+)
+...
+```
+
+### Using `v1` releases
+
+```
+$ GO111MODULE=on go get github.com/urfave/cli
+```
+
+```go
+...
+import (
+ "github.com/urfave/cli"
+)
+...
+```
+
+### GOPATH
+
+Make sure your `PATH` includes the `$GOPATH/bin` directory so your commands can
+be easily used:
+```
+export PATH=$PATH:$GOPATH/bin
+```
+
+### Supported platforms
+
+cli is tested against multiple versions of Go on Linux, and against the latest
+released version of Go on OS X and Windows. This project uses Github Actions for
+builds. For more build info, please look at the [./.github/workflows/cli.yml](https://github.com/urfave/cli/blob/master/.github/workflows/cli.yml).
diff --git a/vendor/github.com/urfave/cli/v2/app.go b/vendor/github.com/urfave/cli/v2/app.go
new file mode 100644
index 0000000000000..c04e9afdaf8bf
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/app.go
@@ -0,0 +1,558 @@
+package cli
+
+import (
+ "context"
+ "flag"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "reflect"
+ "sort"
+ "time"
+)
+
+var (
+ changeLogURL = "https://github.com/urfave/cli/blob/master/docs/CHANGELOG.md"
+ appActionDeprecationURL = fmt.Sprintf("%s#deprecated-cli-app-action-signature", changeLogURL)
+ contactSysadmin = "This is an error in the application. Please contact the distributor of this application if this is not you."
+ errInvalidActionType = NewExitError("ERROR invalid Action type. "+
+ fmt.Sprintf("Must be `func(*Context`)` or `func(*Context) error). %s", contactSysadmin)+
+ fmt.Sprintf("See %s", appActionDeprecationURL), 2)
+)
+
+// App is the main structure of a cli application. It is recommended that
+// an app be created with the cli.NewApp() function
+type App struct {
+ // The name of the program. Defaults to path.Base(os.Args[0])
+ Name string
+ // Full name of command for help, defaults to Name
+ HelpName string
+ // Description of the program.
+ Usage string
+ // Text to override the USAGE section of help
+ UsageText string
+ // Description of the program argument format.
+ ArgsUsage string
+ // Version of the program
+ Version string
+ // Description of the program
+ Description string
+ // List of commands to execute
+ Commands []*Command
+ // List of flags to parse
+ Flags []Flag
+ // Boolean to enable bash completion commands
+ EnableBashCompletion bool
+ // Boolean to hide built-in help command
+ HideHelp bool
+ // Boolean to hide built-in version flag and the VERSION section of help
+ HideVersion bool
+ // categories contains the categorized commands and is populated on app startup
+ categories CommandCategories
+ // An action to execute when the shell completion flag is set
+ BashComplete BashCompleteFunc
+ // An action to execute before any subcommands are run, but after the context is ready
+ // If a non-nil error is returned, no subcommands are run
+ Before BeforeFunc
+ // An action to execute after any subcommands are run, but after the subcommand has finished
+ // It is run even if Action() panics
+ After AfterFunc
+ // The action to execute when no subcommands are specified
+ Action ActionFunc
+ // Execute this function if the proper command cannot be found
+ CommandNotFound CommandNotFoundFunc
+ // Execute this function if an usage error occurs
+ OnUsageError OnUsageErrorFunc
+ // Compilation date
+ Compiled time.Time
+ // List of all authors who contributed
+ Authors []*Author
+ // Copyright of the binary if any
+ Copyright string
+ // Writer writer to write output to
+ Writer io.Writer
+ // ErrWriter writes error output
+ ErrWriter io.Writer
+ // Execute this function to handle ExitErrors. If not provided, HandleExitCoder is provided to
+ // function as a default, so this is optional.
+ ExitErrHandler ExitErrHandlerFunc
+ // Other custom info
+ Metadata map[string]interface{}
+ // Carries a function which returns app specific info.
+ ExtraInfo func() map[string]string
+ // CustomAppHelpTemplate the text template for app help topic.
+ // cli.go uses text/template to render templates. You can
+ // render custom help text by setting this variable.
+ CustomAppHelpTemplate string
+ // Boolean to enable short-option handling so user can combine several
+ // single-character bool arguments into one
+ // i.e. foobar -o -v -> foobar -ov
+ UseShortOptionHandling bool
+
+ didSetup bool
+}
+
+// Tries to find out when this binary was compiled.
+// Returns the current time if it fails to find it.
+func compileTime() time.Time {
+ info, err := os.Stat(os.Args[0])
+ if err != nil {
+ return time.Now()
+ }
+ return info.ModTime()
+}
+
+// NewApp creates a new cli Application with some reasonable defaults for Name,
+// Usage, Version and Action.
+func NewApp() *App {
+ return &App{
+ Name: filepath.Base(os.Args[0]),
+ HelpName: filepath.Base(os.Args[0]),
+ Usage: "A new cli application",
+ UsageText: "",
+ BashComplete: DefaultAppComplete,
+ Action: helpCommand.Action,
+ Compiled: compileTime(),
+ Writer: os.Stdout,
+ }
+}
+
+// Setup runs initialization code to ensure all data structures are ready for
+// `Run` or inspection prior to `Run`. It is internally called by `Run`, but
+// will return early if setup has already happened.
+func (a *App) Setup() {
+ if a.didSetup {
+ return
+ }
+
+ a.didSetup = true
+
+ if a.Name == "" {
+ a.Name = filepath.Base(os.Args[0])
+ }
+
+ if a.HelpName == "" {
+ a.HelpName = filepath.Base(os.Args[0])
+ }
+
+ if a.Usage == "" {
+ a.Usage = "A new cli application"
+ }
+
+ if a.Version == "" {
+ a.HideVersion = true
+ }
+
+ if a.BashComplete == nil {
+ a.BashComplete = DefaultAppComplete
+ }
+
+ if a.Action == nil {
+ a.Action = helpCommand.Action
+ }
+
+ if a.Compiled == (time.Time{}) {
+ a.Compiled = compileTime()
+ }
+
+ if a.Writer == nil {
+ a.Writer = os.Stdout
+ }
+
+ var newCommands []*Command
+
+ for _, c := range a.Commands {
+ if c.HelpName == "" {
+ c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
+ }
+ newCommands = append(newCommands, c)
+ }
+ a.Commands = newCommands
+
+ if a.Command(helpCommand.Name) == nil && !a.HideHelp {
+ a.appendCommand(helpCommand)
+
+ if HelpFlag != nil {
+ a.appendFlag(HelpFlag)
+ }
+ }
+
+ if !a.HideVersion {
+ a.appendFlag(VersionFlag)
+ }
+
+ a.categories = newCommandCategories()
+ for _, command := range a.Commands {
+ a.categories.AddCommand(command.Category, command)
+ }
+ sort.Sort(a.categories.(*commandCategories))
+
+ if a.Metadata == nil {
+ a.Metadata = make(map[string]interface{})
+ }
+
+ if a.Writer == nil {
+ a.Writer = os.Stdout
+ }
+}
+
+func (a *App) newFlagSet() (*flag.FlagSet, error) {
+ return flagSet(a.Name, a.Flags)
+}
+
+func (a *App) useShortOptionHandling() bool {
+ return a.UseShortOptionHandling
+}
+
+// Run is the entry point to the cli app. Parses the arguments slice and routes
+// to the proper flag/args combination
+func (a *App) Run(arguments []string) (err error) {
+ return a.RunContext(context.Background(), arguments)
+}
+
+// RunContext is like Run except it takes a Context that will be
+// passed to its commands and sub-commands. Through this, you can
+// propagate timeouts and cancellation requests
+func (a *App) RunContext(ctx context.Context, arguments []string) (err error) {
+ a.Setup()
+
+ // handle the completion flag separately from the flagset since
+ // completion could be attempted after a flag, but before its value was put
+ // on the command line. this causes the flagset to interpret the completion
+ // flag name as the value of the flag before it which is undesirable
+ // note that we can only do this because the shell autocomplete function
+ // always appends the completion flag at the end of the command
+ shellComplete, arguments := checkShellCompleteFlag(a, arguments)
+
+ set, err := a.newFlagSet()
+ if err != nil {
+ return err
+ }
+
+ err = parseIter(set, a, arguments[1:], shellComplete)
+ nerr := normalizeFlags(a.Flags, set)
+ context := NewContext(a, set, &Context{Context: ctx})
+ if nerr != nil {
+ _, _ = fmt.Fprintln(a.Writer, nerr)
+ _ = ShowAppHelp(context)
+ return nerr
+ }
+ context.shellComplete = shellComplete
+
+ if checkCompletions(context) {
+ return nil
+ }
+
+ if err != nil {
+ if a.OnUsageError != nil {
+ err := a.OnUsageError(context, err, false)
+ a.handleExitCoder(context, err)
+ return err
+ }
+ _, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
+ _ = ShowAppHelp(context)
+ return err
+ }
+
+ if !a.HideHelp && checkHelp(context) {
+ _ = ShowAppHelp(context)
+ return nil
+ }
+
+ if !a.HideVersion && checkVersion(context) {
+ ShowVersion(context)
+ return nil
+ }
+
+ cerr := checkRequiredFlags(a.Flags, context)
+ if cerr != nil {
+ _ = ShowAppHelp(context)
+ return cerr
+ }
+
+ if a.After != nil {
+ defer func() {
+ if afterErr := a.After(context); afterErr != nil {
+ if err != nil {
+ err = newMultiError(err, afterErr)
+ } else {
+ err = afterErr
+ }
+ }
+ }()
+ }
+
+ if a.Before != nil {
+ beforeErr := a.Before(context)
+ if beforeErr != nil {
+ _, _ = fmt.Fprintf(a.Writer, "%v\n\n", beforeErr)
+ _ = ShowAppHelp(context)
+ a.handleExitCoder(context, beforeErr)
+ err = beforeErr
+ return err
+ }
+ }
+
+ args := context.Args()
+ if args.Present() {
+ name := args.First()
+ c := a.Command(name)
+ if c != nil {
+ return c.Run(context)
+ }
+ }
+
+ if a.Action == nil {
+ a.Action = helpCommand.Action
+ }
+
+ // Run default Action
+ err = a.Action(context)
+
+ a.handleExitCoder(context, err)
+ return err
+}
+
+// RunAndExitOnError calls .Run() and exits non-zero if an error was returned
+//
+// Deprecated: instead you should return an error that fulfills cli.ExitCoder
+// to cli.App.Run. This will cause the application to exit with the given eror
+// code in the cli.ExitCoder
+func (a *App) RunAndExitOnError() {
+ if err := a.Run(os.Args); err != nil {
+ _, _ = fmt.Fprintln(a.errWriter(), err)
+ OsExiter(1)
+ }
+}
+
+// RunAsSubcommand invokes the subcommand given the context, parses ctx.Args() to
+// generate command-specific flags
+func (a *App) RunAsSubcommand(ctx *Context) (err error) {
+ a.Setup()
+
+ // append help to commands
+ if len(a.Commands) > 0 {
+ if a.Command(helpCommand.Name) == nil && !a.HideHelp {
+ a.appendCommand(helpCommand)
+
+ if HelpFlag != nil {
+ a.appendFlag(HelpFlag)
+ }
+ }
+ }
+
+ var newCmds []*Command
+ for _, c := range a.Commands {
+ if c.HelpName == "" {
+ c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
+ }
+ newCmds = append(newCmds, c)
+ }
+ a.Commands = newCmds
+
+ set, err := a.newFlagSet()
+ if err != nil {
+ return err
+ }
+
+ err = parseIter(set, a, ctx.Args().Tail(), ctx.shellComplete)
+ nerr := normalizeFlags(a.Flags, set)
+ context := NewContext(a, set, ctx)
+
+ if nerr != nil {
+ _, _ = fmt.Fprintln(a.Writer, nerr)
+ _, _ = fmt.Fprintln(a.Writer)
+ if len(a.Commands) > 0 {
+ _ = ShowSubcommandHelp(context)
+ } else {
+ _ = ShowCommandHelp(ctx, context.Args().First())
+ }
+ return nerr
+ }
+
+ if checkCompletions(context) {
+ return nil
+ }
+
+ if err != nil {
+ if a.OnUsageError != nil {
+ err = a.OnUsageError(context, err, true)
+ a.handleExitCoder(context, err)
+ return err
+ }
+ _, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
+ _ = ShowSubcommandHelp(context)
+ return err
+ }
+
+ if len(a.Commands) > 0 {
+ if checkSubcommandHelp(context) {
+ return nil
+ }
+ } else {
+ if checkCommandHelp(ctx, context.Args().First()) {
+ return nil
+ }
+ }
+
+ cerr := checkRequiredFlags(a.Flags, context)
+ if cerr != nil {
+ _ = ShowSubcommandHelp(context)
+ return cerr
+ }
+
+ if a.After != nil {
+ defer func() {
+ afterErr := a.After(context)
+ if afterErr != nil {
+ a.handleExitCoder(context, err)
+ if err != nil {
+ err = newMultiError(err, afterErr)
+ } else {
+ err = afterErr
+ }
+ }
+ }()
+ }
+
+ if a.Before != nil {
+ beforeErr := a.Before(context)
+ if beforeErr != nil {
+ a.handleExitCoder(context, beforeErr)
+ err = beforeErr
+ return err
+ }
+ }
+
+ args := context.Args()
+ if args.Present() {
+ name := args.First()
+ c := a.Command(name)
+ if c != nil {
+ return c.Run(context)
+ }
+ }
+
+ // Run default Action
+ err = a.Action(context)
+
+ a.handleExitCoder(context, err)
+ return err
+}
+
+// Command returns the named command on App. Returns nil if the command does not exist
+func (a *App) Command(name string) *Command {
+ for _, c := range a.Commands {
+ if c.HasName(name) {
+ return c
+ }
+ }
+
+ return nil
+}
+
+// VisibleCategories returns a slice of categories and commands that are
+// Hidden=false
+func (a *App) VisibleCategories() []CommandCategory {
+ ret := []CommandCategory{}
+ for _, category := range a.categories.Categories() {
+ if visible := func() CommandCategory {
+ if len(category.VisibleCommands()) > 0 {
+ return category
+ }
+ return nil
+ }(); visible != nil {
+ ret = append(ret, visible)
+ }
+ }
+ return ret
+}
+
+// VisibleCommands returns a slice of the Commands with Hidden=false
+func (a *App) VisibleCommands() []*Command {
+ var ret []*Command
+ for _, command := range a.Commands {
+ if !command.Hidden {
+ ret = append(ret, command)
+ }
+ }
+ return ret
+}
+
+// VisibleFlags returns a slice of the Flags with Hidden=false
+func (a *App) VisibleFlags() []Flag {
+ return visibleFlags(a.Flags)
+}
+
+func (a *App) hasFlag(flag Flag) bool {
+ for _, f := range a.Flags {
+ if reflect.DeepEqual(flag, f) {
+ return true
+ }
+ }
+
+ return false
+}
+
+func (a *App) errWriter() io.Writer {
+ // When the app ErrWriter is nil use the package level one.
+ if a.ErrWriter == nil {
+ return ErrWriter
+ }
+
+ return a.ErrWriter
+}
+
+func (a *App) appendFlag(fl Flag) {
+ if !hasFlag(a.Flags, fl) {
+ a.Flags = append(a.Flags, fl)
+ }
+}
+
+func (a *App) appendCommand(c *Command) {
+ if !hasCommand(a.Commands, c) {
+ a.Commands = append(a.Commands, c)
+ }
+}
+
+func (a *App) handleExitCoder(context *Context, err error) {
+ if a.ExitErrHandler != nil {
+ a.ExitErrHandler(context, err)
+ } else {
+ HandleExitCoder(err)
+ }
+}
+
+// Author represents someone who has contributed to a cli project.
+type Author struct {
+ Name string // The Authors name
+ Email string // The Authors email
+}
+
+// String makes Author comply to the Stringer interface, to allow an easy print in the templating process
+func (a *Author) String() string {
+ e := ""
+ if a.Email != "" {
+ e = " <" + a.Email + ">"
+ }
+
+ return fmt.Sprintf("%v%v", a.Name, e)
+}
+
+// HandleAction attempts to figure out which Action signature was used. If
+// it's an ActionFunc or a func with the legacy signature for Action, the func
+// is run!
+func HandleAction(action interface{}, context *Context) (err error) {
+ switch a := action.(type) {
+ case ActionFunc:
+ return a(context)
+ case func(*Context) error:
+ return a(context)
+ case func(*Context): // deprecated function signature
+ a(context)
+ return nil
+ }
+
+ return errInvalidActionType
+}
diff --git a/vendor/github.com/urfave/cli/v2/appveyor.yml b/vendor/github.com/urfave/cli/v2/appveyor.yml
new file mode 100644
index 0000000000000..f1cae90b59a04
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/appveyor.yml
@@ -0,0 +1,28 @@
+version: "{build}"
+
+os: Windows Server 2016
+
+image: Visual Studio 2017
+
+clone_folder: c:\gopath\src\github.com\urfave\cli
+
+cache:
+ - node_modules
+
+environment:
+ GOPATH: C:\gopath
+ GOVERSION: 1.11.x
+ GO111MODULE: on
+ GOPROXY: https://proxy.golang.org
+
+install:
+ - set PATH=%GOPATH%\bin;C:\go\bin;%PATH%
+ - go version
+ - go env
+ - go get github.com/urfave/gfmrun/cmd/gfmrun
+ - go mod tidy
+
+build_script:
+ - go run build.go vet
+ - go run build.go test
+ - go run build.go gfmrun docs/v1/manual.md
diff --git a/vendor/github.com/urfave/cli/v2/args.go b/vendor/github.com/urfave/cli/v2/args.go
new file mode 100644
index 0000000000000..bd65c17bde6de
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/args.go
@@ -0,0 +1,54 @@
+package cli
+
+type Args interface {
+ // Get returns the nth argument, or else a blank string
+ Get(n int) string
+ // First returns the first argument, or else a blank string
+ First() string
+ // Tail returns the rest of the arguments (not the first one)
+ // or else an empty string slice
+ Tail() []string
+ // Len returns the length of the wrapped slice
+ Len() int
+ // Present checks if there are any arguments present
+ Present() bool
+ // Slice returns a copy of the internal slice
+ Slice() []string
+}
+
+type args []string
+
+func (a *args) Get(n int) string {
+ if len(*a) > n {
+ return (*a)[n]
+ }
+ return ""
+}
+
+func (a *args) First() string {
+ return a.Get(0)
+}
+
+func (a *args) Tail() []string {
+ if a.Len() >= 2 {
+ tail := []string((*a)[1:])
+ ret := make([]string, len(tail))
+ copy(ret, tail)
+ return ret
+ }
+ return []string{}
+}
+
+func (a *args) Len() int {
+ return len(*a)
+}
+
+func (a *args) Present() bool {
+ return a.Len() != 0
+}
+
+func (a *args) Slice() []string {
+ ret := make([]string, len(*a))
+ copy(ret, *a)
+ return ret
+}
diff --git a/vendor/github.com/urfave/cli/v2/category.go b/vendor/github.com/urfave/cli/v2/category.go
new file mode 100644
index 0000000000000..867e3908ca378
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/category.go
@@ -0,0 +1,79 @@
+package cli
+
+// CommandCategories interface allows for category manipulation
+type CommandCategories interface {
+ // AddCommand adds a command to a category, creating a new category if necessary.
+ AddCommand(category string, command *Command)
+ // categories returns a copy of the category slice
+ Categories() []CommandCategory
+}
+
+type commandCategories []*commandCategory
+
+func newCommandCategories() CommandCategories {
+ ret := commandCategories([]*commandCategory{})
+ return &ret
+}
+
+func (c *commandCategories) Less(i, j int) bool {
+ return lexicographicLess((*c)[i].Name(), (*c)[j].Name())
+}
+
+func (c *commandCategories) Len() int {
+ return len(*c)
+}
+
+func (c *commandCategories) Swap(i, j int) {
+ (*c)[i], (*c)[j] = (*c)[j], (*c)[i]
+}
+
+func (c *commandCategories) AddCommand(category string, command *Command) {
+ for _, commandCategory := range []*commandCategory(*c) {
+ if commandCategory.name == category {
+ commandCategory.commands = append(commandCategory.commands, command)
+ return
+ }
+ }
+ newVal := append(*c,
+ &commandCategory{name: category, commands: []*Command{command}})
+ *c = newVal
+}
+
+func (c *commandCategories) Categories() []CommandCategory {
+ ret := make([]CommandCategory, len(*c))
+ for i, cat := range *c {
+ ret[i] = cat
+ }
+ return ret
+}
+
+// CommandCategory is a category containing commands.
+type CommandCategory interface {
+ // Name returns the category name string
+ Name() string
+ // VisibleCommands returns a slice of the Commands with Hidden=false
+ VisibleCommands() []*Command
+}
+
+type commandCategory struct {
+ name string
+ commands []*Command
+}
+
+func (c *commandCategory) Name() string {
+ return c.name
+}
+
+func (c *commandCategory) VisibleCommands() []*Command {
+ if c.commands == nil {
+ c.commands = []*Command{}
+ }
+
+ var ret []*Command
+ for _, command := range c.commands {
+ if !command.Hidden {
+ ret = append(ret, command)
+ }
+ }
+ return ret
+}
diff --git a/vendor/github.com/urfave/cli/v2/cli.go b/vendor/github.com/urfave/cli/v2/cli.go
new file mode 100644
index 0000000000000..62a5bc22d26c4
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/cli.go
@@ -0,0 +1,23 @@
+// Package cli provides a minimal framework for creating and organizing command line
+// Go applications. cli is designed to be easy to understand and write, the most simple
+// cli application can be written as follows:
+// func main() {
+// (&cli.App{}).Run(os.Args)
+// }
+//
+// Of course this application does not do much, so let's make this an actual application:
+// func main() {
+// app := &cli.App{
+// Name: "greet",
+// Usage: "say a greeting",
+// Action: func(c *cli.Context) error {
+// fmt.Println("Greetings")
+// return nil
+// },
+// }
+//
+// app.Run(os.Args)
+// }
+package cli
+
+//go:generate go run flag-gen/main.go flag-gen/assets_vfsdata.go
diff --git a/vendor/github.com/urfave/cli/v2/command.go b/vendor/github.com/urfave/cli/v2/command.go
new file mode 100644
index 0000000000000..db6c8024ba87b
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/command.go
@@ -0,0 +1,297 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "sort"
+ "strings"
+)
+
+// Command is a subcommand for a cli.App.
+type Command struct {
+ // The name of the command
+ Name string
+ // A list of aliases for the command
+ Aliases []string
+ // A short description of the usage of this command
+ Usage string
+ // Custom text to show on USAGE section of help
+ UsageText string
+ // A longer explanation of how the command works
+ Description string
+ // A short description of the arguments of this command
+ ArgsUsage string
+ // The category the command is part of
+ Category string
+ // The function to call when checking for bash command completions
+ BashComplete BashCompleteFunc
+ // An action to execute before any sub-subcommands are run, but after the context is ready
+ // If a non-nil error is returned, no sub-subcommands are run
+ Before BeforeFunc
+ // An action to execute after any subcommands are run, but after the subcommand has finished
+ // It is run even if Action() panics
+ After AfterFunc
+ // The function to call when this command is invoked
+ Action ActionFunc
+ // Execute this function if a usage error occurs.
+ OnUsageError OnUsageErrorFunc
+ // List of child commands
+ Subcommands []*Command
+ // List of flags to parse
+ Flags []Flag
+ // Treat all flags as normal arguments if true
+ SkipFlagParsing bool
+ // Boolean to hide built-in help command
+ HideHelp bool
+ // Boolean to hide this command from help or completion
+ Hidden bool
+ // Boolean to enable short-option handling so user can combine several
+ // single-character bool arguments into one
+ // i.e. foobar -o -v -> foobar -ov
+ UseShortOptionHandling bool
+
+ // Full name of command for help, defaults to full command name, including parent commands.
+ HelpName string
+ commandNamePath []string
+
+ // CustomHelpTemplate the text template for the command help topic.
+ // cli.go uses text/template to render templates. You can
+ // render custom help text by setting this variable.
+ CustomHelpTemplate string
+}
+
+type Commands []*Command
+
+type CommandsByName []*Command
+
+func (c CommandsByName) Len() int {
+ return len(c)
+}
+
+func (c CommandsByName) Less(i, j int) bool {
+ return lexicographicLess(c[i].Name, c[j].Name)
+}
+
+func (c CommandsByName) Swap(i, j int) {
+ c[i], c[j] = c[j], c[i]
+}
+
+// FullName returns the full name of the command.
+// For subcommands this ensures that parent commands are part of the command path
+func (c *Command) FullName() string {
+ if c.commandNamePath == nil {
+ return c.Name
+ }
+ return strings.Join(c.commandNamePath, " ")
+}
+
+// Run invokes the command given the context, parses ctx.Args() to generate command-specific flags
+func (c *Command) Run(ctx *Context) (err error) {
+ if len(c.Subcommands) > 0 {
+ return c.startApp(ctx)
+ }
+
+ if !c.HideHelp && HelpFlag != nil {
+ // append help to flags
+ c.appendFlag(HelpFlag)
+ }
+
+ if ctx.App.UseShortOptionHandling {
+ c.UseShortOptionHandling = true
+ }
+
+ set, err := c.parseFlags(ctx.Args(), ctx.shellComplete)
+
+ context := NewContext(ctx.App, set, ctx)
+ context.Command = c
+ if checkCommandCompletions(context, c.Name) {
+ return nil
+ }
+
+ if err != nil {
+ if c.OnUsageError != nil {
+ err = c.OnUsageError(context, err, false)
+ context.App.handleExitCoder(context, err)
+ return err
+ }
+ _, _ = fmt.Fprintln(context.App.Writer, "Incorrect Usage:", err.Error())
+ _, _ = fmt.Fprintln(context.App.Writer)
+ _ = ShowCommandHelp(context, c.Name)
+ return err
+ }
+
+ if checkCommandHelp(context, c.Name) {
+ return nil
+ }
+
+ cerr := checkRequiredFlags(c.Flags, context)
+ if cerr != nil {
+ _ = ShowCommandHelp(context, c.Name)
+ return cerr
+ }
+
+ if c.After != nil {
+ defer func() {
+ afterErr := c.After(context)
+ if afterErr != nil {
+ context.App.handleExitCoder(context, err)
+ if err != nil {
+ err = newMultiError(err, afterErr)
+ } else {
+ err = afterErr
+ }
+ }
+ }()
+ }
+
+ if c.Before != nil {
+ err = c.Before(context)
+ if err != nil {
+ _ = ShowCommandHelp(context, c.Name)
+ context.App.handleExitCoder(context, err)
+ return err
+ }
+ }
+
+ if c.Action == nil {
+ c.Action = helpSubcommand.Action
+ }
+
+ context.Command = c
+ err = c.Action(context)
+
+ if err != nil {
+ context.App.handleExitCoder(context, err)
+ }
+ return err
+}
+
+func (c *Command) newFlagSet() (*flag.FlagSet, error) {
+ return flagSet(c.Name, c.Flags)
+}
+
+func (c *Command) useShortOptionHandling() bool {
+ return c.UseShortOptionHandling
+}
+
+func (c *Command) parseFlags(args Args, shellComplete bool) (*flag.FlagSet, error) {
+ set, err := c.newFlagSet()
+ if err != nil {
+ return nil, err
+ }
+
+ if c.SkipFlagParsing {
+ return set, set.Parse(append([]string{"--"}, args.Tail()...))
+ }
+
+ err = parseIter(set, c, args.Tail(), shellComplete)
+ if err != nil {
+ return nil, err
+ }
+
+ err = normalizeFlags(c.Flags, set)
+ if err != nil {
+ return nil, err
+ }
+
+ return set, nil
+}
+
+// Names returns the names including short names and aliases.
+func (c *Command) Names() []string {
+ return append([]string{c.Name}, c.Aliases...)
+}
+
+// HasName returns true if Command.Name matches given name
+func (c *Command) HasName(name string) bool {
+ for _, n := range c.Names() {
+ if n == name {
+ return true
+ }
+ }
+ return false
+}
+
+func (c *Command) startApp(ctx *Context) error {
+ app := &App{
+ Metadata: ctx.App.Metadata,
+ Name: fmt.Sprintf("%s %s", ctx.App.Name, c.Name),
+ }
+
+ if c.HelpName == "" {
+ app.HelpName = c.HelpName
+ } else {
+ app.HelpName = app.Name
+ }
+
+ app.Usage = c.Usage
+ app.Description = c.Description
+ app.ArgsUsage = c.ArgsUsage
+
+ // set CommandNotFound
+ app.CommandNotFound = ctx.App.CommandNotFound
+ app.CustomAppHelpTemplate = c.CustomHelpTemplate
+
+ // set the flags and commands
+ app.Commands = c.Subcommands
+ app.Flags = c.Flags
+ app.HideHelp = c.HideHelp
+
+ app.Version = ctx.App.Version
+ app.HideVersion = ctx.App.HideVersion
+ app.Compiled = ctx.App.Compiled
+ app.Writer = ctx.App.Writer
+ app.ErrWriter = ctx.App.ErrWriter
+ app.ExitErrHandler = ctx.App.ExitErrHandler
+ app.UseShortOptionHandling = ctx.App.UseShortOptionHandling
+
+ app.categories = newCommandCategories()
+ for _, command := range c.Subcommands {
+ app.categories.AddCommand(command.Category, command)
+ }
+
+ sort.Sort(app.categories.(*commandCategories))
+
+ // bash completion
+ app.EnableBashCompletion = ctx.App.EnableBashCompletion
+ if c.BashComplete != nil {
+ app.BashComplete = c.BashComplete
+ }
+
+ // set the actions
+ app.Before = c.Before
+ app.After = c.After
+ if c.Action != nil {
+ app.Action = c.Action
+ } else {
+ app.Action = helpSubcommand.Action
+ }
+ app.OnUsageError = c.OnUsageError
+
+ for index, cc := range app.Commands {
+ app.Commands[index].commandNamePath = []string{c.Name, cc.Name}
+ }
+
+ return app.RunAsSubcommand(ctx)
+}
+
+// VisibleFlags returns a slice of the Flags with Hidden=false
+func (c *Command) VisibleFlags() []Flag {
+ return visibleFlags(c.Flags)
+}
+
+func (c *Command) appendFlag(fl Flag) {
+ if !hasFlag(c.Flags, fl) {
+ c.Flags = append(c.Flags, fl)
+ }
+}
+
+func hasCommand(commands []*Command, command *Command) bool {
+ for _, existing := range commands {
+ if command == existing {
+ return true
+ }
+ }
+
+ return false
+}
diff --git a/vendor/github.com/urfave/cli/v2/context.go b/vendor/github.com/urfave/cli/v2/context.go
new file mode 100644
index 0000000000000..c0c526f41124f
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/context.go
@@ -0,0 +1,274 @@
+package cli
+
+import (
+ "context"
+ "errors"
+ "flag"
+ "fmt"
+ "strings"
+)
+
+// Context is a type that is passed through to
+// each Handler action in a cli application. Context
+// can be used to retrieve context-specific args and
+// parsed command-line options.
+type Context struct {
+ context.Context
+ App *App
+ Command *Command
+ shellComplete bool
+ setFlags map[string]bool
+ flagSet *flag.FlagSet
+ parentContext *Context
+}
+
+// NewContext creates a new context. For use in when invoking an App or Command action.
+func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
+ c := &Context{App: app, flagSet: set, parentContext: parentCtx}
+ if parentCtx != nil {
+ c.Context = parentCtx.Context
+ c.shellComplete = parentCtx.shellComplete
+ if parentCtx.flagSet == nil {
+ parentCtx.flagSet = &flag.FlagSet{}
+ }
+ }
+
+ c.Command = &Command{}
+
+ if c.Context == nil {
+ c.Context = context.Background()
+ }
+
+ return c
+}
+
+// NumFlags returns the number of flags set
+func (c *Context) NumFlags() int {
+ return c.flagSet.NFlag()
+}
+
+// Set sets a context flag to a value.
+func (c *Context) Set(name, value string) error {
+ return c.flagSet.Set(name, value)
+}
+
+// IsSet determines if the flag was actually set
+func (c *Context) IsSet(name string) bool {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ isSet := false
+ fs.Visit(func(f *flag.Flag) {
+ if f.Name == name {
+ isSet = true
+ }
+ })
+ if isSet {
+ return true
+ }
+ }
+
+ f := lookupFlag(name, c)
+ if f == nil {
+ return false
+ }
+
+ return f.IsSet()
+ }
+
+ return false
+}
+
+// LocalFlagNames returns a slice of flag names used in this context.
+func (c *Context) LocalFlagNames() []string {
+ var names []string
+ c.flagSet.Visit(makeFlagNameVisitor(&names))
+ return names
+}
+
+// FlagNames returns a slice of flag names used by the this context and all of
+// its parent contexts.
+func (c *Context) FlagNames() []string {
+ var names []string
+ for _, ctx := range c.Lineage() {
+ ctx.flagSet.Visit(makeFlagNameVisitor(&names))
+ }
+ return names
+}
+
+// Lineage returns *this* context and all of its ancestor contexts in order from
+// child to parent
+func (c *Context) Lineage() []*Context {
+ var lineage []*Context
+
+ for cur := c; cur != nil; cur = cur.parentContext {
+ lineage = append(lineage, cur)
+ }
+
+ return lineage
+}
+
+// Value returns the value of the flag corresponding to `name`
+func (c *Context) Value(name string) interface{} {
+ return c.flagSet.Lookup(name).Value.(flag.Getter).Get()
+}
+
+// Args returns the command line arguments associated with the context.
+func (c *Context) Args() Args {
+ ret := args(c.flagSet.Args())
+ return &ret
+}
+
+// NArg returns the number of the command line arguments.
+func (c *Context) NArg() int {
+ return c.Args().Len()
+}
+
+func lookupFlag(name string, ctx *Context) Flag {
+ for _, c := range ctx.Lineage() {
+ if c.Command == nil {
+ continue
+ }
+
+ for _, f := range c.Command.Flags {
+ for _, n := range f.Names() {
+ if n == name {
+ return f
+ }
+ }
+ }
+ }
+
+ if ctx.App != nil {
+ for _, f := range ctx.App.Flags {
+ for _, n := range f.Names() {
+ if n == name {
+ return f
+ }
+ }
+ }
+ }
+
+ return nil
+}
+
+func lookupFlagSet(name string, ctx *Context) *flag.FlagSet {
+ for _, c := range ctx.Lineage() {
+ if f := c.flagSet.Lookup(name); f != nil {
+ return c.flagSet
+ }
+ }
+
+ return nil
+}
+
+func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
+ switch ff.Value.(type) {
+ case Serializer:
+ _ = set.Set(name, ff.Value.(Serializer).Serialize())
+ default:
+ _ = set.Set(name, ff.Value.String())
+ }
+}
+
+func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
+ visited := make(map[string]bool)
+ set.Visit(func(f *flag.Flag) {
+ visited[f.Name] = true
+ })
+ for _, f := range flags {
+ parts := f.Names()
+ if len(parts) == 1 {
+ continue
+ }
+ var ff *flag.Flag
+ for _, name := range parts {
+ name = strings.Trim(name, " ")
+ if visited[name] {
+ if ff != nil {
+ return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
+ }
+ ff = set.Lookup(name)
+ }
+ }
+ if ff == nil {
+ continue
+ }
+ for _, name := range parts {
+ name = strings.Trim(name, " ")
+ if !visited[name] {
+ copyFlag(name, ff, set)
+ }
+ }
+ }
+ return nil
+}
+
+func makeFlagNameVisitor(names *[]string) func(*flag.Flag) {
+ return func(f *flag.Flag) {
+ nameParts := strings.Split(f.Name, ",")
+ name := strings.TrimSpace(nameParts[0])
+
+ for _, part := range nameParts {
+ part = strings.TrimSpace(part)
+ if len(part) > len(name) {
+ name = part
+ }
+ }
+
+ if name != "" {
+ *names = append(*names, name)
+ }
+ }
+}
+
+type requiredFlagsErr interface {
+ error
+ getMissingFlags() []string
+}
+
+type errRequiredFlags struct {
+ missingFlags []string
+}
+
+func (e *errRequiredFlags) Error() string {
+ numberOfMissingFlags := len(e.missingFlags)
+ if numberOfMissingFlags == 1 {
+ return fmt.Sprintf("Required flag %q not set", e.missingFlags[0])
+ }
+ joinedMissingFlags := strings.Join(e.missingFlags, ", ")
+ return fmt.Sprintf("Required flags %q not set", joinedMissingFlags)
+}
+
+func (e *errRequiredFlags) getMissingFlags() []string {
+ return e.missingFlags
+}
+
+func checkRequiredFlags(flags []Flag, context *Context) requiredFlagsErr {
+ var missingFlags []string
+ for _, f := range flags {
+ if rf, ok := f.(RequiredFlag); ok && rf.IsRequired() {
+ var flagPresent bool
+ var flagName string
+
+ for _, key := range f.Names() {
+ if len(key) > 1 {
+ flagName = key
+ }
+
+ if context.IsSet(strings.TrimSpace(key)) {
+ flagPresent = true
+ }
+ }
+
+ if !flagPresent && flagName != "" {
+ missingFlags = append(missingFlags, flagName)
+ }
+ }
+ }
+
+ if len(missingFlags) != 0 {
+ return &errRequiredFlags{missingFlags: missingFlags}
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/urfave/cli/v2/docs.go b/vendor/github.com/urfave/cli/v2/docs.go
new file mode 100644
index 0000000000000..dc16fc82d45e3
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/docs.go
@@ -0,0 +1,148 @@
+package cli
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "sort"
+ "strings"
+ "text/template"
+
+ "github.com/cpuguy83/go-md2man/v2/md2man"
+)
+
+// ToMarkdown creates a markdown string for the `*App`
+// The function errors if either parsing or writing of the string fails.
+func (a *App) ToMarkdown() (string, error) {
+ var w bytes.Buffer
+ if err := a.writeDocTemplate(&w); err != nil {
+ return "", err
+ }
+ return w.String(), nil
+}
+
+// ToMan creates a man page string for the `*App`
+// The function errors if either parsing or writing of the string fails.
+func (a *App) ToMan() (string, error) {
+ var w bytes.Buffer
+ if err := a.writeDocTemplate(&w); err != nil {
+ return "", err
+ }
+ man := md2man.Render(w.Bytes())
+ return string(man), nil
+}
+
+type cliTemplate struct {
+ App *App
+ Commands []string
+ GlobalArgs []string
+ SynopsisArgs []string
+}
+
+func (a *App) writeDocTemplate(w io.Writer) error {
+ const name = "cli"
+ t, err := template.New(name).Parse(MarkdownDocTemplate)
+ if err != nil {
+ return err
+ }
+ return t.ExecuteTemplate(w, name, &cliTemplate{
+ App: a,
+ Commands: prepareCommands(a.Commands, 0),
+ GlobalArgs: prepareArgsWithValues(a.VisibleFlags()),
+ SynopsisArgs: prepareArgsSynopsis(a.VisibleFlags()),
+ })
+}
+
+func prepareCommands(commands []*Command, level int) []string {
+ var coms []string
+ for _, command := range commands {
+ if command.Hidden {
+ continue
+ }
+ usage := ""
+ if command.Usage != "" {
+ usage = command.Usage
+ }
+
+ prepared := fmt.Sprintf("%s %s\n\n%s\n",
+ strings.Repeat("#", level+2),
+ strings.Join(command.Names(), ", "),
+ usage,
+ )
+
+ flags := prepareArgsWithValues(command.Flags)
+ if len(flags) > 0 {
+ prepared += fmt.Sprintf("\n%s", strings.Join(flags, "\n"))
+ }
+
+ coms = append(coms, prepared)
+
+ // recursevly iterate subcommands
+ if len(command.Subcommands) > 0 {
+ coms = append(
+ coms,
+ prepareCommands(command.Subcommands, level+1)...,
+ )
+ }
+ }
+
+ return coms
+}
+
+func prepareArgsWithValues(flags []Flag) []string {
+ return prepareFlags(flags, ", ", "**", "**", `""`, true)
+}
+
+func prepareArgsSynopsis(flags []Flag) []string {
+ return prepareFlags(flags, "|", "[", "]", "[value]", false)
+}
+
+func prepareFlags(
+ flags []Flag,
+ sep, opener, closer, value string,
+ addDetails bool,
+) []string {
+ args := []string{}
+ for _, f := range flags {
+ flag, ok := f.(DocGenerationFlag)
+ if !ok {
+ continue
+ }
+ modifiedArg := opener
+
+ for _, s := range flag.Names() {
+ trimmed := strings.TrimSpace(s)
+ if len(modifiedArg) > len(opener) {
+ modifiedArg += sep
+ }
+ if len(trimmed) > 1 {
+ modifiedArg += fmt.Sprintf("--%s", trimmed)
+ } else {
+ modifiedArg += fmt.Sprintf("-%s", trimmed)
+ }
+ }
+ modifiedArg += closer
+ if flag.TakesValue() {
+ modifiedArg += fmt.Sprintf("=%s", value)
+ }
+
+ if addDetails {
+ modifiedArg += flagDetails(flag)
+ }
+
+ args = append(args, modifiedArg+"\n")
+
+ }
+ sort.Strings(args)
+ return args
+}
+
+// flagDetails returns a string containing the flags metadata
+func flagDetails(flag DocGenerationFlag) string {
+ description := flag.GetUsage()
+ value := flag.GetValue()
+ if value != "" {
+ description += " (default: " + value + ")"
+ }
+ return ": " + description
+}
diff --git a/vendor/github.com/urfave/cli/v2/errors.go b/vendor/github.com/urfave/cli/v2/errors.go
new file mode 100644
index 0000000000000..344b4361e97c3
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/errors.go
@@ -0,0 +1,131 @@
+package cli
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "strings"
+)
+
+// OsExiter is the function used when the app exits. If not set defaults to os.Exit.
+var OsExiter = os.Exit
+
+// ErrWriter is used to write errors to the user. This can be anything
+// implementing the io.Writer interface and defaults to os.Stderr.
+var ErrWriter io.Writer = os.Stderr
+
+// MultiError is an error that wraps multiple errors.
+type MultiError interface {
+ error
+ // Errors returns a copy of the errors slice
+ Errors() []error
+}
+
+// NewMultiError creates a new MultiError. Pass in one or more errors.
+func newMultiError(err ...error) MultiError {
+ ret := multiError(err)
+ return &ret
+}
+
+type multiError []error
+
+// Error implements the error interface.
+func (m *multiError) Error() string {
+ errs := make([]string, len(*m))
+ for i, err := range *m {
+ errs[i] = err.Error()
+ }
+
+ return strings.Join(errs, "\n")
+}
+
+// Errors returns a copy of the errors slice
+func (m *multiError) Errors() []error {
+ errs := make([]error, len(*m))
+ for _, err := range *m {
+ errs = append(errs, err)
+ }
+ return errs
+}
+
+// ErrorFormatter is the interface that will suitably format the error output
+type ErrorFormatter interface {
+ Format(s fmt.State, verb rune)
+}
+
+// ExitCoder is the interface checked by `App` and `Command` for a custom exit
+// code
+type ExitCoder interface {
+ error
+ ExitCode() int
+}
+
+type exitError struct {
+ exitCode int
+ message interface{}
+}
+
+// NewExitError makes a new *exitError
+func NewExitError(message interface{}, exitCode int) ExitCoder {
+ return Exit(message, exitCode)
+}
+
+// Exit wraps a message and exit code into an ExitCoder suitable for handling by
+// HandleExitCoder
+func Exit(message interface{}, exitCode int) ExitCoder {
+ return &exitError{
+ message: message,
+ exitCode: exitCode,
+ }
+}
+
+func (ee *exitError) Error() string {
+ return fmt.Sprintf("%v", ee.message)
+}
+
+func (ee *exitError) ExitCode() int {
+ return ee.exitCode
+}
+
+// HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
+// so prints the error to stderr (if it is non-empty) and calls OsExiter with the
+// given exit code. If the given error is a MultiError, then this func is
+// called on all members of the Errors slice and calls OsExiter with the last exit code.
+func HandleExitCoder(err error) {
+ if err == nil {
+ return
+ }
+
+ if exitErr, ok := err.(ExitCoder); ok {
+ if err.Error() != "" {
+ if _, ok := exitErr.(ErrorFormatter); ok {
+ _, _ = fmt.Fprintf(ErrWriter, "%+v\n", err)
+ } else {
+ _, _ = fmt.Fprintln(ErrWriter, err)
+ }
+ }
+ OsExiter(exitErr.ExitCode())
+ return
+ }
+
+ if multiErr, ok := err.(MultiError); ok {
+ code := handleMultiError(multiErr)
+ OsExiter(code)
+ return
+ }
+}
+
+func handleMultiError(multiErr MultiError) int {
+ code := 1
+ for _, merr := range multiErr.Errors() {
+ if multiErr2, ok := merr.(MultiError); ok {
+ code = handleMultiError(multiErr2)
+ } else if merr != nil {
+ fmt.Fprintln(ErrWriter, merr)
+ if exitErr, ok := merr.(ExitCoder); ok {
+ code = exitErr.ExitCode()
+ }
+ }
+ }
+ return code
+}
diff --git a/vendor/github.com/urfave/cli/v2/fish.go b/vendor/github.com/urfave/cli/v2/fish.go
new file mode 100644
index 0000000000000..67122c9fe7de4
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/fish.go
@@ -0,0 +1,192 @@
+package cli
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "strings"
+ "text/template"
+)
+
+// ToFishCompletion creates a fish completion string for the `*App`
+// The function errors if either parsing or writing of the string fails.
+func (a *App) ToFishCompletion() (string, error) {
+ var w bytes.Buffer
+ if err := a.writeFishCompletionTemplate(&w); err != nil {
+ return "", err
+ }
+ return w.String(), nil
+}
+
+type fishCompletionTemplate struct {
+ App *App
+ Completions []string
+ AllCommands []string
+}
+
+func (a *App) writeFishCompletionTemplate(w io.Writer) error {
+ const name = "cli"
+ t, err := template.New(name).Parse(FishCompletionTemplate)
+ if err != nil {
+ return err
+ }
+ allCommands := []string{}
+
+ // Add global flags
+ completions := a.prepareFishFlags(a.VisibleFlags(), allCommands)
+
+ // Add help flag
+ if !a.HideHelp {
+ completions = append(
+ completions,
+ a.prepareFishFlags([]Flag{HelpFlag}, allCommands)...,
+ )
+ }
+
+ // Add version flag
+ if !a.HideVersion {
+ completions = append(
+ completions,
+ a.prepareFishFlags([]Flag{VersionFlag}, allCommands)...,
+ )
+ }
+
+ // Add commands and their flags
+ completions = append(
+ completions,
+ a.prepareFishCommands(a.VisibleCommands(), &allCommands, []string{})...,
+ )
+
+ return t.ExecuteTemplate(w, name, &fishCompletionTemplate{
+ App: a,
+ Completions: completions,
+ AllCommands: allCommands,
+ })
+}
+
+func (a *App) prepareFishCommands(commands []*Command, allCommands *[]string, previousCommands []string) []string {
+ completions := []string{}
+ for _, command := range commands {
+ if command.Hidden {
+ continue
+ }
+
+ var completion strings.Builder
+ completion.WriteString(fmt.Sprintf(
+ "complete -r -c %s -n '%s' -a '%s'",
+ a.Name,
+ a.fishSubcommandHelper(previousCommands),
+ strings.Join(command.Names(), " "),
+ ))
+
+ if command.Usage != "" {
+ completion.WriteString(fmt.Sprintf(" -d '%s'",
+ escapeSingleQuotes(command.Usage)))
+ }
+
+ if !command.HideHelp {
+ completions = append(
+ completions,
+ a.prepareFishFlags([]Flag{HelpFlag}, command.Names())...,
+ )
+ }
+
+ *allCommands = append(*allCommands, command.Names()...)
+ completions = append(completions, completion.String())
+ completions = append(
+ completions,
+ a.prepareFishFlags(command.Flags, command.Names())...,
+ )
+
+ // recursevly iterate subcommands
+ if len(command.Subcommands) > 0 {
+ completions = append(
+ completions,
+ a.prepareFishCommands(
+ command.Subcommands, allCommands, command.Names(),
+ )...,
+ )
+ }
+ }
+
+ return completions
+}
+
+func (a *App) prepareFishFlags(flags []Flag, previousCommands []string) []string {
+ completions := []string{}
+ for _, f := range flags {
+ flag, ok := f.(DocGenerationFlag)
+ if !ok {
+ continue
+ }
+
+ completion := &strings.Builder{}
+ completion.WriteString(fmt.Sprintf(
+ "complete -c %s -n '%s'",
+ a.Name,
+ a.fishSubcommandHelper(previousCommands),
+ ))
+
+ fishAddFileFlag(f, completion)
+
+ for idx, opt := range flag.Names() {
+ if idx == 0 {
+ completion.WriteString(fmt.Sprintf(
+ " -l %s", strings.TrimSpace(opt),
+ ))
+ } else {
+ completion.WriteString(fmt.Sprintf(
+ " -s %s", strings.TrimSpace(opt),
+ ))
+
+ }
+ }
+
+ if flag.TakesValue() {
+ completion.WriteString(" -r")
+ }
+
+ if flag.GetUsage() != "" {
+ completion.WriteString(fmt.Sprintf(" -d '%s'",
+ escapeSingleQuotes(flag.GetUsage())))
+ }
+
+ completions = append(completions, completion.String())
+ }
+
+ return completions
+}
+
+func fishAddFileFlag(flag Flag, completion *strings.Builder) {
+ switch f := flag.(type) {
+ case *GenericFlag:
+ if f.TakesFile {
+ return
+ }
+ case *StringFlag:
+ if f.TakesFile {
+ return
+ }
+ case *StringSliceFlag:
+ if f.TakesFile {
+ return
+ }
+ }
+ completion.WriteString(" -f")
+}
+
+func (a *App) fishSubcommandHelper(allCommands []string) string {
+ fishHelper := fmt.Sprintf("__fish_%s_no_subcommand", a.Name)
+ if len(allCommands) > 0 {
+ fishHelper = fmt.Sprintf(
+ "__fish_seen_subcommand_from %s",
+ strings.Join(allCommands, " "),
+ )
+ }
+ return fishHelper
+
+}
+
+func escapeSingleQuotes(input string) string {
+ return strings.Replace(input, `'`, `\'`, -1)
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag.go b/vendor/github.com/urfave/cli/v2/flag.go
new file mode 100644
index 0000000000000..ec128fd44069e
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag.go
@@ -0,0 +1,398 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "io/ioutil"
+ "reflect"
+ "regexp"
+ "runtime"
+ "strconv"
+ "strings"
+ "syscall"
+ "time"
+)
+
+const defaultPlaceholder = "value"
+
+var (
+ slPfx = fmt.Sprintf("sl:::%d:::", time.Now().UTC().UnixNano())
+
+ commaWhitespace = regexp.MustCompile("[, ]+.*")
+)
+
+// BashCompletionFlag enables bash-completion for all commands and subcommands
+var BashCompletionFlag Flag = &BoolFlag{
+ Name: "generate-bash-completion",
+ Hidden: true,
+}
+
+// VersionFlag prints the version for the application
+var VersionFlag Flag = &BoolFlag{
+ Name: "version",
+ Aliases: []string{"v"},
+ Usage: "print the version",
+}
+
+// HelpFlag prints the help for all commands and subcommands.
+// Set to nil to disable the flag. The subcommand
+// will still be added unless HideHelp is set to true.
+var HelpFlag Flag = &BoolFlag{
+ Name: "help",
+ Aliases: []string{"h"},
+ Usage: "show help",
+}
+
+// FlagStringer converts a flag definition to a string. This is used by help
+// to display a flag.
+var FlagStringer FlagStringFunc = stringifyFlag
+
+// Serializer is used to circumvent the limitations of flag.FlagSet.Set
+type Serializer interface {
+ Serialize() string
+}
+
+// FlagNamePrefixer converts a full flag name and its placeholder into the help
+// message flag prefix. This is used by the default FlagStringer.
+var FlagNamePrefixer FlagNamePrefixFunc = prefixedNames
+
+// FlagEnvHinter annotates flag help message with the environment variable
+// details. This is used by the default FlagStringer.
+var FlagEnvHinter FlagEnvHintFunc = withEnvHint
+
+// FlagFileHinter annotates flag help message with the environment variable
+// details. This is used by the default FlagStringer.
+var FlagFileHinter FlagFileHintFunc = withFileHint
+
+// FlagsByName is a slice of Flag.
+type FlagsByName []Flag
+
+func (f FlagsByName) Len() int {
+ return len(f)
+}
+
+func (f FlagsByName) Less(i, j int) bool {
+ if len(f[j].Names()) == 0 {
+ return false
+ } else if len(f[i].Names()) == 0 {
+ return true
+ }
+ return lexicographicLess(f[i].Names()[0], f[j].Names()[0])
+}
+
+func (f FlagsByName) Swap(i, j int) {
+ f[i], f[j] = f[j], f[i]
+}
+
+// Flag is a common interface related to parsing flags in cli.
+// For more advanced flag parsing techniques, it is recommended that
+// this interface be implemented.
+type Flag interface {
+ fmt.Stringer
+ // Apply Flag settings to the given flag set
+ Apply(*flag.FlagSet) error
+ Names() []string
+ IsSet() bool
+}
+
+// RequiredFlag is an interface that allows us to mark flags as required
+// it allows flags required flags to be backwards compatible with the Flag interface
+type RequiredFlag interface {
+ Flag
+
+ IsRequired() bool
+}
+
+// DocGenerationFlag is an interface that allows documentation generation for the flag
+type DocGenerationFlag interface {
+ Flag
+
+ // TakesValue returns true if the flag takes a value, otherwise false
+ TakesValue() bool
+
+ // GetUsage returns the usage string for the flag
+ GetUsage() string
+
+ // GetValue returns the flags value as string representation and an empty
+ // string if the flag takes no value at all.
+ GetValue() string
+}
+
+func flagSet(name string, flags []Flag) (*flag.FlagSet, error) {
+ set := flag.NewFlagSet(name, flag.ContinueOnError)
+
+ for _, f := range flags {
+ if err := f.Apply(set); err != nil {
+ return nil, err
+ }
+ }
+ set.SetOutput(ioutil.Discard)
+ return set, nil
+}
+
+func visibleFlags(fl []Flag) []Flag {
+ var visible []Flag
+ for _, f := range fl {
+ field := flagValue(f).FieldByName("Hidden")
+ if !field.IsValid() || !field.Bool() {
+ visible = append(visible, f)
+ }
+ }
+ return visible
+}
+
+func prefixFor(name string) (prefix string) {
+ if len(name) == 1 {
+ prefix = "-"
+ } else {
+ prefix = "--"
+ }
+
+ return
+}
+
+// Returns the placeholder, if any, and the unquoted usage string.
+func unquoteUsage(usage string) (string, string) {
+ for i := 0; i < len(usage); i++ {
+ if usage[i] == '`' {
+ for j := i + 1; j < len(usage); j++ {
+ if usage[j] == '`' {
+ name := usage[i+1 : j]
+ usage = usage[:i] + name + usage[j+1:]
+ return name, usage
+ }
+ }
+ break
+ }
+ }
+ return "", usage
+}
+
+func prefixedNames(names []string, placeholder string) string {
+ var prefixed string
+ for i, name := range names {
+ if name == "" {
+ continue
+ }
+
+ prefixed += prefixFor(name) + name
+ if placeholder != "" {
+ prefixed += " " + placeholder
+ }
+ if i < len(names)-1 {
+ prefixed += ", "
+ }
+ }
+ return prefixed
+}
+
+func withEnvHint(envVars []string, str string) string {
+ envText := ""
+ if envVars != nil && len(envVars) > 0 {
+ prefix := "$"
+ suffix := ""
+ sep := ", $"
+ if runtime.GOOS == "windows" {
+ prefix = "%"
+ suffix = "%"
+ sep = "%, %"
+ }
+
+ envText = fmt.Sprintf(" [%s%s%s]", prefix, strings.Join(envVars, sep), suffix)
+ }
+ return str + envText
+}
+
+func flagNames(f Flag) []string {
+ var ret []string
+
+ name := flagStringField(f, "Name")
+ aliases := flagStringSliceField(f, "Aliases")
+
+ for _, part := range append([]string{name}, aliases...) {
+ // v1 -> v2 migration warning zone:
+ // Strip off anything after the first found comma or space, which
+ // *hopefully* makes it a tiny bit more obvious that unexpected behavior is
+ // caused by using the v1 form of stringly typed "Name".
+ ret = append(ret, commaWhitespace.ReplaceAllString(part, ""))
+ }
+
+ return ret
+}
+
+func flagStringSliceField(f Flag, name string) []string {
+ fv := flagValue(f)
+ field := fv.FieldByName(name)
+
+ if field.IsValid() {
+ return field.Interface().([]string)
+ }
+
+ return []string{}
+}
+
+func flagStringField(f Flag, name string) string {
+ fv := flagValue(f)
+ field := fv.FieldByName(name)
+
+ if field.IsValid() {
+ return field.String()
+ }
+
+ return ""
+}
+
+func withFileHint(filePath, str string) string {
+ fileText := ""
+ if filePath != "" {
+ fileText = fmt.Sprintf(" [%s]", filePath)
+ }
+ return str + fileText
+}
+
+func flagValue(f Flag) reflect.Value {
+ fv := reflect.ValueOf(f)
+ for fv.Kind() == reflect.Ptr {
+ fv = reflect.Indirect(fv)
+ }
+ return fv
+}
+
+func stringifyFlag(f Flag) string {
+ fv := flagValue(f)
+
+ switch f.(type) {
+ case *IntSliceFlag:
+ return withEnvHint(flagStringSliceField(f, "EnvVars"),
+ stringifyIntSliceFlag(f.(*IntSliceFlag)))
+ case *Int64SliceFlag:
+ return withEnvHint(flagStringSliceField(f, "EnvVars"),
+ stringifyInt64SliceFlag(f.(*Int64SliceFlag)))
+ case *Float64SliceFlag:
+ return withEnvHint(flagStringSliceField(f, "EnvVars"),
+ stringifyFloat64SliceFlag(f.(*Float64SliceFlag)))
+ case *StringSliceFlag:
+ return withEnvHint(flagStringSliceField(f, "EnvVars"),
+ stringifyStringSliceFlag(f.(*StringSliceFlag)))
+ }
+
+ placeholder, usage := unquoteUsage(fv.FieldByName("Usage").String())
+
+ needsPlaceholder := false
+ defaultValueString := ""
+ val := fv.FieldByName("Value")
+ if val.IsValid() {
+ needsPlaceholder = val.Kind() != reflect.Bool
+ defaultValueString = fmt.Sprintf(" (default: %v)", val.Interface())
+
+ if val.Kind() == reflect.String && val.String() != "" {
+ defaultValueString = fmt.Sprintf(" (default: %q)", val.String())
+ }
+ }
+
+ helpText := fv.FieldByName("DefaultText")
+ if helpText.IsValid() && helpText.String() != "" {
+ needsPlaceholder = val.Kind() != reflect.Bool
+ defaultValueString = fmt.Sprintf(" (default: %s)", helpText.String())
+ }
+
+ if defaultValueString == " (default: )" {
+ defaultValueString = ""
+ }
+
+ if needsPlaceholder && placeholder == "" {
+ placeholder = defaultPlaceholder
+ }
+
+ usageWithDefault := strings.TrimSpace(usage + defaultValueString)
+
+ return withEnvHint(flagStringSliceField(f, "EnvVars"),
+ fmt.Sprintf("%s\t%s", prefixedNames(f.Names(), placeholder), usageWithDefault))
+}
+
+func stringifyIntSliceFlag(f *IntSliceFlag) string {
+ var defaultVals []string
+ if f.Value != nil && len(f.Value.Value()) > 0 {
+ for _, i := range f.Value.Value() {
+ defaultVals = append(defaultVals, strconv.Itoa(i))
+ }
+ }
+
+ return stringifySliceFlag(f.Usage, f.Names(), defaultVals)
+}
+
+func stringifyInt64SliceFlag(f *Int64SliceFlag) string {
+ var defaultVals []string
+ if f.Value != nil && len(f.Value.Value()) > 0 {
+ for _, i := range f.Value.Value() {
+ defaultVals = append(defaultVals, strconv.FormatInt(i, 10))
+ }
+ }
+
+ return stringifySliceFlag(f.Usage, f.Names(), defaultVals)
+}
+
+func stringifyFloat64SliceFlag(f *Float64SliceFlag) string {
+ var defaultVals []string
+
+ if f.Value != nil && len(f.Value.Value()) > 0 {
+ for _, i := range f.Value.Value() {
+ defaultVals = append(defaultVals, strings.TrimRight(strings.TrimRight(fmt.Sprintf("%f", i), "0"), "."))
+ }
+ }
+
+ return stringifySliceFlag(f.Usage, f.Names(), defaultVals)
+}
+
+func stringifyStringSliceFlag(f *StringSliceFlag) string {
+ var defaultVals []string
+ if f.Value != nil && len(f.Value.Value()) > 0 {
+ for _, s := range f.Value.Value() {
+ if len(s) > 0 {
+ defaultVals = append(defaultVals, strconv.Quote(s))
+ }
+ }
+ }
+
+ return stringifySliceFlag(f.Usage, f.Names(), defaultVals)
+}
+
+func stringifySliceFlag(usage string, names, defaultVals []string) string {
+ placeholder, usage := unquoteUsage(usage)
+ if placeholder == "" {
+ placeholder = defaultPlaceholder
+ }
+
+ defaultVal := ""
+ if len(defaultVals) > 0 {
+ defaultVal = fmt.Sprintf(" (default: %s)", strings.Join(defaultVals, ", "))
+ }
+
+ usageWithDefault := strings.TrimSpace(fmt.Sprintf("%s%s", usage, defaultVal))
+ return fmt.Sprintf("%s\t%s", prefixedNames(names, placeholder), usageWithDefault)
+}
+
+func hasFlag(flags []Flag, fl Flag) bool {
+ for _, existing := range flags {
+ if fl == existing {
+ return true
+ }
+ }
+
+ return false
+}
+
+func flagFromEnvOrFile(envVars []string, filePath string) (val string, ok bool) {
+ for _, envVar := range envVars {
+ envVar = strings.TrimSpace(envVar)
+ if val, ok := syscall.Getenv(envVar); ok {
+ return val, true
+ }
+ }
+ for _, fileVar := range strings.Split(filePath, ",") {
+ if data, err := ioutil.ReadFile(fileVar); err == nil {
+ return string(data), true
+ }
+ }
+ return "", false
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_bool.go b/vendor/github.com/urfave/cli/v2/flag_bool.go
new file mode 100644
index 0000000000000..6a1da61efde9d
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_bool.go
@@ -0,0 +1,106 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "strconv"
+)
+
+// BoolFlag is a flag with type bool
+type BoolFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value bool
+ DefaultText string
+ Destination *bool
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *BoolFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *BoolFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *BoolFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *BoolFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *BoolFlag) TakesValue() bool {
+ return false
+}
+
+// GetUsage returns the usage string for the flag
+func (f *BoolFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *BoolFlag) GetValue() string {
+ return ""
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *BoolFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ valBool, err := strconv.ParseBool(val)
+
+ if err != nil {
+ return fmt.Errorf("could not parse %q as bool value for flag %s: %s", val, f.Name, err)
+ }
+
+ f.Value = valBool
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.BoolVar(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.Bool(name, f.Value, f.Usage)
+ }
+
+ return nil
+}
+
+// Bool looks up the value of a local BoolFlag, returns
+// false if not found
+func (c *Context) Bool(name string) bool {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupBool(name, fs)
+ }
+ return false
+}
+
+func lookupBool(name string, set *flag.FlagSet) bool {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := strconv.ParseBool(f.Value.String())
+ if err != nil {
+ return false
+ }
+ return parsed
+ }
+ return false
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_duration.go b/vendor/github.com/urfave/cli/v2/flag_duration.go
new file mode 100644
index 0000000000000..2c34944a4b5c3
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_duration.go
@@ -0,0 +1,105 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "time"
+)
+
+// DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration)
+type DurationFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value time.Duration
+ DefaultText string
+ Destination *time.Duration
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *DurationFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *DurationFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *DurationFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *DurationFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *DurationFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *DurationFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *DurationFlag) GetValue() string {
+ return f.Value.String()
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *DurationFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ valDuration, err := time.ParseDuration(val)
+
+ if err != nil {
+ return fmt.Errorf("could not parse %q as duration value for flag %s: %s", val, f.Name, err)
+ }
+
+ f.Value = valDuration
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.DurationVar(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.Duration(name, f.Value, f.Usage)
+ }
+ return nil
+}
+
+// Duration looks up the value of a local DurationFlag, returns
+// 0 if not found
+func (c *Context) Duration(name string) time.Duration {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupDuration(name, fs)
+ }
+ return 0
+}
+
+func lookupDuration(name string, set *flag.FlagSet) time.Duration {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := time.ParseDuration(f.Value.String())
+ if err != nil {
+ return 0
+ }
+ return parsed
+ }
+ return 0
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_float64.go b/vendor/github.com/urfave/cli/v2/flag_float64.go
new file mode 100644
index 0000000000000..31f06f35e5ff9
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_float64.go
@@ -0,0 +1,106 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "strconv"
+)
+
+// Float64Flag is a flag with type float64
+type Float64Flag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value float64
+ DefaultText string
+ Destination *float64
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Float64Flag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *Float64Flag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *Float64Flag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *Float64Flag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *Float64Flag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *Float64Flag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *Float64Flag) GetValue() string {
+ return fmt.Sprintf("%f", f.Value)
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *Float64Flag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ valFloat, err := strconv.ParseFloat(val, 10)
+
+ if err != nil {
+ return fmt.Errorf("could not parse %q as float64 value for flag %s: %s", val, f.Name, err)
+ }
+
+ f.Value = valFloat
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.Float64Var(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.Float64(name, f.Value, f.Usage)
+ }
+
+ return nil
+}
+
+// Float64 looks up the value of a local Float64Flag, returns
+// 0 if not found
+func (c *Context) Float64(name string) float64 {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupFloat64(name, fs)
+ }
+ return 0
+}
+
+func lookupFloat64(name string, set *flag.FlagSet) float64 {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := strconv.ParseFloat(f.Value.String(), 64)
+ if err != nil {
+ return 0
+ }
+ return parsed
+ }
+ return 0
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_float64_slice.go b/vendor/github.com/urfave/cli/v2/flag_float64_slice.go
new file mode 100644
index 0000000000000..91d2e9d100490
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_float64_slice.go
@@ -0,0 +1,165 @@
+package cli
+
+import (
+ "encoding/json"
+ "flag"
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+// Float64Slice wraps []float64 to satisfy flag.Value
+type Float64Slice struct {
+ slice []float64
+ hasBeenSet bool
+}
+
+// NewFloat64Slice makes a *Float64Slice with default values
+func NewFloat64Slice(defaults ...float64) *Float64Slice {
+ return &Float64Slice{slice: append([]float64{}, defaults...)}
+}
+
+// Set parses the value into a float64 and appends it to the list of values
+func (f *Float64Slice) Set(value string) error {
+ if !f.hasBeenSet {
+ f.slice = []float64{}
+ f.hasBeenSet = true
+ }
+
+ if strings.HasPrefix(value, slPfx) {
+ // Deserializing assumes overwrite
+ _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &f.slice)
+ f.hasBeenSet = true
+ return nil
+ }
+
+ tmp, err := strconv.ParseFloat(value, 64)
+ if err != nil {
+ return err
+ }
+
+ f.slice = append(f.slice, tmp)
+ return nil
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *Float64Slice) String() string {
+ return fmt.Sprintf("%#v", f.slice)
+}
+
+// Serialize allows Float64Slice to fulfill Serializer
+func (f *Float64Slice) Serialize() string {
+ jsonBytes, _ := json.Marshal(f.slice)
+ return fmt.Sprintf("%s%s", slPfx, string(jsonBytes))
+}
+
+// Value returns the slice of float64s set by this flag
+func (f *Float64Slice) Value() []float64 {
+ return f.slice
+}
+
+// Get returns the slice of float64s set by this flag
+func (f *Float64Slice) Get() interface{} {
+ return *f
+}
+
+// Float64SliceFlag is a flag with type *Float64Slice
+type Float64SliceFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value *Float64Slice
+ DefaultText string
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Float64SliceFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *Float64SliceFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *Float64SliceFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *Float64SliceFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true if the flag takes a value, otherwise false
+func (f *Float64SliceFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *Float64SliceFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *Float64SliceFlag) GetValue() string {
+ if f.Value != nil {
+ return f.Value.String()
+ }
+ return ""
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *Float64SliceFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ f.Value = &Float64Slice{}
+
+ for _, s := range strings.Split(val, ",") {
+ if err := f.Value.Set(strings.TrimSpace(s)); err != nil {
+ return fmt.Errorf("could not parse %q as float64 slice value for flag %s: %s", f.Value, f.Name, err)
+ }
+ }
+
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ if f.Value == nil {
+ f.Value = &Float64Slice{}
+ }
+ set.Var(f.Value, name, f.Usage)
+ }
+
+ return nil
+}
+
+// Float64Slice looks up the value of a local Float64SliceFlag, returns
+// nil if not found
+func (c *Context) Float64Slice(name string) []float64 {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupFloat64Slice(name, fs)
+ }
+ return nil
+}
+
+func lookupFloat64Slice(name string, set *flag.FlagSet) []float64 {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := (f.Value.(*Float64Slice)).Value(), error(nil)
+ if err != nil {
+ return nil
+ }
+ return parsed
+ }
+ return nil
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_generic.go b/vendor/github.com/urfave/cli/v2/flag_generic.go
new file mode 100644
index 0000000000000..2d9baa78de9cd
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_generic.go
@@ -0,0 +1,108 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+)
+
+// Generic is a generic parseable type identified by a specific flag
+type Generic interface {
+ Set(value string) error
+ String() string
+}
+
+// GenericFlag is a flag with type Generic
+type GenericFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ TakesFile bool
+ Value Generic
+ DefaultText string
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *GenericFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *GenericFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *GenericFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *GenericFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *GenericFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *GenericFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *GenericFlag) GetValue() string {
+ if f.Value != nil {
+ return f.Value.String()
+ }
+ return ""
+}
+
+// Apply takes the flagset and calls Set on the generic flag with the value
+// provided by the user for parsing by the flag
+func (f GenericFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ if err := f.Value.Set(val); err != nil {
+ return fmt.Errorf("could not parse %q as value for flag %s: %s", val, f.Name, err)
+ }
+
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ set.Var(f.Value, name, f.Usage)
+ }
+
+ return nil
+}
+
+// Generic looks up the value of a local GenericFlag, returns
+// nil if not found
+func (c *Context) Generic(name string) interface{} {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupGeneric(name, fs)
+ }
+ return nil
+}
+
+func lookupGeneric(name string, set *flag.FlagSet) interface{} {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := f.Value, error(nil)
+ if err != nil {
+ return nil
+ }
+ return parsed
+ }
+ return nil
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_int.go b/vendor/github.com/urfave/cli/v2/flag_int.go
new file mode 100644
index 0000000000000..be961bf5f1a12
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_int.go
@@ -0,0 +1,106 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "strconv"
+)
+
+// IntFlag is a flag with type int
+type IntFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value int
+ DefaultText string
+ Destination *int
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *IntFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *IntFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *IntFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *IntFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *IntFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *IntFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *IntFlag) GetValue() string {
+ return fmt.Sprintf("%d", f.Value)
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *IntFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ valInt, err := strconv.ParseInt(val, 0, 64)
+
+ if err != nil {
+ return fmt.Errorf("could not parse %q as int value for flag %s: %s", val, f.Name, err)
+ }
+
+ f.Value = int(valInt)
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.IntVar(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.Int(name, f.Value, f.Usage)
+ }
+
+ return nil
+}
+
+// Int looks up the value of a local IntFlag, returns
+// 0 if not found
+func (c *Context) Int(name string) int {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupInt(name, fs)
+ }
+ return 0
+}
+
+func lookupInt(name string, set *flag.FlagSet) int {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
+ if err != nil {
+ return 0
+ }
+ return int(parsed)
+ }
+ return 0
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_int64.go b/vendor/github.com/urfave/cli/v2/flag_int64.go
new file mode 100644
index 0000000000000..c979119f8e25c
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_int64.go
@@ -0,0 +1,105 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "strconv"
+)
+
+// Int64Flag is a flag with type int64
+type Int64Flag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value int64
+ DefaultText string
+ Destination *int64
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Int64Flag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *Int64Flag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *Int64Flag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *Int64Flag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *Int64Flag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *Int64Flag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *Int64Flag) GetValue() string {
+ return fmt.Sprintf("%d", f.Value)
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *Int64Flag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ valInt, err := strconv.ParseInt(val, 0, 64)
+
+ if err != nil {
+ return fmt.Errorf("could not parse %q as int value for flag %s: %s", val, f.Name, err)
+ }
+
+ f.Value = valInt
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.Int64Var(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.Int64(name, f.Value, f.Usage)
+ }
+ return nil
+}
+
+// Int64 looks up the value of a local Int64Flag, returns
+// 0 if not found
+func (c *Context) Int64(name string) int64 {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupInt64(name, fs)
+ }
+ return 0
+}
+
+func lookupInt64(name string, set *flag.FlagSet) int64 {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
+ if err != nil {
+ return 0
+ }
+ return parsed
+ }
+ return 0
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_int64_slice.go b/vendor/github.com/urfave/cli/v2/flag_int64_slice.go
new file mode 100644
index 0000000000000..41aa0667e6db8
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_int64_slice.go
@@ -0,0 +1,161 @@
+package cli
+
+import (
+ "encoding/json"
+ "flag"
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+// Int64Slice wraps []int64 to satisfy flag.Value
+type Int64Slice struct {
+ slice []int64
+ hasBeenSet bool
+}
+
+// NewInt64Slice makes an *Int64Slice with default values
+func NewInt64Slice(defaults ...int64) *Int64Slice {
+ return &Int64Slice{slice: append([]int64{}, defaults...)}
+}
+
+// Set parses the value into an integer and appends it to the list of values
+func (i *Int64Slice) Set(value string) error {
+ if !i.hasBeenSet {
+ i.slice = []int64{}
+ i.hasBeenSet = true
+ }
+
+ if strings.HasPrefix(value, slPfx) {
+ // Deserializing assumes overwrite
+ _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &i.slice)
+ i.hasBeenSet = true
+ return nil
+ }
+
+ tmp, err := strconv.ParseInt(value, 0, 64)
+ if err != nil {
+ return err
+ }
+
+ i.slice = append(i.slice, tmp)
+
+ return nil
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (i *Int64Slice) String() string {
+ return fmt.Sprintf("%#v", i.slice)
+}
+
+// Serialize allows Int64Slice to fulfill Serializer
+func (i *Int64Slice) Serialize() string {
+ jsonBytes, _ := json.Marshal(i.slice)
+ return fmt.Sprintf("%s%s", slPfx, string(jsonBytes))
+}
+
+// Value returns the slice of ints set by this flag
+func (i *Int64Slice) Value() []int64 {
+ return i.slice
+}
+
+// Get returns the slice of ints set by this flag
+func (i *Int64Slice) Get() interface{} {
+ return *i
+}
+
+// Int64SliceFlag is a flag with type *Int64Slice
+type Int64SliceFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value *Int64Slice
+ DefaultText string
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Int64SliceFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *Int64SliceFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *Int64SliceFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *Int64SliceFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *Int64SliceFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f Int64SliceFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *Int64SliceFlag) GetValue() string {
+ if f.Value != nil {
+ return f.Value.String()
+ }
+ return ""
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *Int64SliceFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ f.Value = &Int64Slice{}
+
+ for _, s := range strings.Split(val, ",") {
+ if err := f.Value.Set(strings.TrimSpace(s)); err != nil {
+ return fmt.Errorf("could not parse %q as int64 slice value for flag %s: %s", val, f.Name, err)
+ }
+ }
+
+ f.HasBeenSet = true
+ }
+
+ for _, name := range f.Names() {
+ if f.Value == nil {
+ f.Value = &Int64Slice{}
+ }
+ set.Var(f.Value, name, f.Usage)
+ }
+
+ return nil
+}
+
+// Int64Slice looks up the value of a local Int64SliceFlag, returns
+// nil if not found
+func (c *Context) Int64Slice(name string) []int64 {
+ return lookupInt64Slice(name, c.flagSet)
+}
+
+func lookupInt64Slice(name string, set *flag.FlagSet) []int64 {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := (f.Value.(*Int64Slice)).Value(), error(nil)
+ if err != nil {
+ return nil
+ }
+ return parsed
+ }
+ return nil
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_int_slice.go b/vendor/github.com/urfave/cli/v2/flag_int_slice.go
new file mode 100644
index 0000000000000..93889784216a9
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_int_slice.go
@@ -0,0 +1,175 @@
+package cli
+
+import (
+ "encoding/json"
+ "flag"
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+// IntSlice wraps []int to satisfy flag.Value
+type IntSlice struct {
+ slice []int
+ hasBeenSet bool
+}
+
+// NewIntSlice makes an *IntSlice with default values
+func NewIntSlice(defaults ...int) *IntSlice {
+ return &IntSlice{slice: append([]int{}, defaults...)}
+}
+
+// TODO: Consistently have specific Set function for Int64 and Float64 ?
+// SetInt directly adds an integer to the list of values
+func (i *IntSlice) SetInt(value int) {
+ if !i.hasBeenSet {
+ i.slice = []int{}
+ i.hasBeenSet = true
+ }
+
+ i.slice = append(i.slice, value)
+}
+
+// Set parses the value into an integer and appends it to the list of values
+func (i *IntSlice) Set(value string) error {
+ if !i.hasBeenSet {
+ i.slice = []int{}
+ i.hasBeenSet = true
+ }
+
+ if strings.HasPrefix(value, slPfx) {
+ // Deserializing assumes overwrite
+ _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &i.slice)
+ i.hasBeenSet = true
+ return nil
+ }
+
+ tmp, err := strconv.ParseInt(value, 0, 64)
+ if err != nil {
+ return err
+ }
+
+ i.slice = append(i.slice, int(tmp))
+
+ return nil
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (i *IntSlice) String() string {
+ return fmt.Sprintf("%#v", i.slice)
+}
+
+// Serialize allows IntSlice to fulfill Serializer
+func (i *IntSlice) Serialize() string {
+ jsonBytes, _ := json.Marshal(i.slice)
+ return fmt.Sprintf("%s%s", slPfx, string(jsonBytes))
+}
+
+// Value returns the slice of ints set by this flag
+func (i *IntSlice) Value() []int {
+ return i.slice
+}
+
+// Get returns the slice of ints set by this flag
+func (i *IntSlice) Get() interface{} {
+ return *i
+}
+
+// IntSliceFlag is a flag with type *IntSlice
+type IntSliceFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value *IntSlice
+ DefaultText string
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *IntSliceFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *IntSliceFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *IntSliceFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *IntSliceFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *IntSliceFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f IntSliceFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *IntSliceFlag) GetValue() string {
+ if f.Value != nil {
+ return f.Value.String()
+ }
+ return ""
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *IntSliceFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ f.Value = &IntSlice{}
+
+ for _, s := range strings.Split(val, ",") {
+ if err := f.Value.Set(strings.TrimSpace(s)); err != nil {
+ return fmt.Errorf("could not parse %q as int slice value for flag %s: %s", val, f.Name, err)
+ }
+ }
+
+ f.HasBeenSet = true
+ }
+
+ for _, name := range f.Names() {
+ if f.Value == nil {
+ f.Value = &IntSlice{}
+ }
+ set.Var(f.Value, name, f.Usage)
+ }
+
+ return nil
+}
+
+// IntSlice looks up the value of a local IntSliceFlag, returns
+// nil if not found
+func (c *Context) IntSlice(name string) []int {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupIntSlice(name, c.flagSet)
+ }
+ return nil
+}
+
+func lookupIntSlice(name string, set *flag.FlagSet) []int {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := (f.Value.(*IntSlice)).Value(), error(nil)
+ if err != nil {
+ return nil
+ }
+ return parsed
+ }
+ return nil
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_path.go b/vendor/github.com/urfave/cli/v2/flag_path.go
new file mode 100644
index 0000000000000..a322857395478
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_path.go
@@ -0,0 +1,95 @@
+package cli
+
+import "flag"
+
+type PathFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ TakesFile bool
+ Value string
+ DefaultText string
+ Destination *string
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *PathFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *PathFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *PathFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *PathFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *PathFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *PathFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *PathFlag) GetValue() string {
+ return f.Value
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *PathFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ f.Value = val
+ f.HasBeenSet = true
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.StringVar(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.String(name, f.Value, f.Usage)
+ }
+
+ return nil
+}
+
+// Path looks up the value of a local PathFlag, returns
+// "" if not found
+func (c *Context) Path(name string) string {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupPath(name, fs)
+ }
+
+ return ""
+}
+
+func lookupPath(name string, set *flag.FlagSet) string {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := f.Value.String(), error(nil)
+ if err != nil {
+ return ""
+ }
+ return parsed
+ }
+ return ""
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_string.go b/vendor/github.com/urfave/cli/v2/flag_string.go
new file mode 100644
index 0000000000000..bcd82530cc632
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_string.go
@@ -0,0 +1,95 @@
+package cli
+
+import "flag"
+
+// StringFlag is a flag with type string
+type StringFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ TakesFile bool
+ Value string
+ DefaultText string
+ Destination *string
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *StringFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *StringFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *StringFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *StringFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *StringFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *StringFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *StringFlag) GetValue() string {
+ return f.Value
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *StringFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ f.Value = val
+ f.HasBeenSet = true
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.StringVar(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.String(name, f.Value, f.Usage)
+ }
+
+ return nil
+}
+
+// String looks up the value of a local StringFlag, returns
+// "" if not found
+func (c *Context) String(name string) string {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupString(name, fs)
+ }
+ return ""
+}
+
+func lookupString(name string, set *flag.FlagSet) string {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := f.Value.String(), error(nil)
+ if err != nil {
+ return ""
+ }
+ return parsed
+ }
+ return ""
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_string_slice.go b/vendor/github.com/urfave/cli/v2/flag_string_slice.go
new file mode 100644
index 0000000000000..a114a495eb138
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_string_slice.go
@@ -0,0 +1,159 @@
+package cli
+
+import (
+ "encoding/json"
+ "flag"
+ "fmt"
+ "strings"
+)
+
+// StringSlice wraps a []string to satisfy flag.Value
+type StringSlice struct {
+ slice []string
+ hasBeenSet bool
+}
+
+// NewStringSlice creates a *StringSlice with default values
+func NewStringSlice(defaults ...string) *StringSlice {
+ return &StringSlice{slice: append([]string{}, defaults...)}
+}
+
+// Set appends the string value to the list of values
+func (s *StringSlice) Set(value string) error {
+ if !s.hasBeenSet {
+ s.slice = []string{}
+ s.hasBeenSet = true
+ }
+
+ if strings.HasPrefix(value, slPfx) {
+ // Deserializing assumes overwrite
+ _ = json.Unmarshal([]byte(strings.Replace(value, slPfx, "", 1)), &s.slice)
+ s.hasBeenSet = true
+ return nil
+ }
+
+ s.slice = append(s.slice, value)
+
+ return nil
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (s *StringSlice) String() string {
+ return fmt.Sprintf("%s", s.slice)
+}
+
+// Serialize allows StringSlice to fulfill Serializer
+func (s *StringSlice) Serialize() string {
+ jsonBytes, _ := json.Marshal(s.slice)
+ return fmt.Sprintf("%s%s", slPfx, string(jsonBytes))
+}
+
+// Value returns the slice of strings set by this flag
+func (s *StringSlice) Value() []string {
+ return s.slice
+}
+
+// Get returns the slice of strings set by this flag
+func (s *StringSlice) Get() interface{} {
+ return *s
+}
+
+// StringSliceFlag is a flag with type *StringSlice
+type StringSliceFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ TakesFile bool
+ Value *StringSlice
+ DefaultText string
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *StringSliceFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *StringSliceFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *StringSliceFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *StringSliceFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *StringSliceFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *StringSliceFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *StringSliceFlag) GetValue() string {
+ if f.Value != nil {
+ return f.Value.String()
+ }
+ return ""
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *StringSliceFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ f.Value = &StringSlice{}
+
+ for _, s := range strings.Split(val, ",") {
+ if err := f.Value.Set(strings.TrimSpace(s)); err != nil {
+ return fmt.Errorf("could not parse %q as string value for flag %s: %s", val, f.Name, err)
+ }
+ }
+
+ f.HasBeenSet = true
+ }
+
+ for _, name := range f.Names() {
+ if f.Value == nil {
+ f.Value = &StringSlice{}
+ }
+ set.Var(f.Value, name, f.Usage)
+ }
+
+ return nil
+}
+
+// StringSlice looks up the value of a local StringSliceFlag, returns
+// nil if not found
+func (c *Context) StringSlice(name string) []string {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupStringSlice(name, fs)
+ }
+ return nil
+}
+
+func lookupStringSlice(name string, set *flag.FlagSet) []string {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := (f.Value.(*StringSlice)).Value(), error(nil)
+ if err != nil {
+ return nil
+ }
+ return parsed
+ }
+ return nil
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_timestamp.go b/vendor/github.com/urfave/cli/v2/flag_timestamp.go
new file mode 100644
index 0000000000000..d24edcd7f218d
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_timestamp.go
@@ -0,0 +1,152 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "time"
+)
+
+// Timestamp wrap to satisfy golang's flag interface.
+type Timestamp struct {
+ timestamp *time.Time
+ hasBeenSet bool
+ layout string
+}
+
+// Timestamp constructor
+func NewTimestamp(timestamp time.Time) *Timestamp {
+ return &Timestamp{timestamp: ×tamp}
+}
+
+// Set the timestamp value directly
+func (t *Timestamp) SetTimestamp(value time.Time) {
+ if !t.hasBeenSet {
+ t.timestamp = &value
+ t.hasBeenSet = true
+ }
+}
+
+// Set the timestamp string layout for future parsing
+func (t *Timestamp) SetLayout(layout string) {
+ t.layout = layout
+}
+
+// Parses the string value to timestamp
+func (t *Timestamp) Set(value string) error {
+ timestamp, err := time.Parse(t.layout, value)
+ if err != nil {
+ return err
+ }
+
+ t.timestamp = ×tamp
+ t.hasBeenSet = true
+ return nil
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (t *Timestamp) String() string {
+ return fmt.Sprintf("%#v", t.timestamp)
+}
+
+// Value returns the timestamp value stored in the flag
+func (t *Timestamp) Value() *time.Time {
+ return t.timestamp
+}
+
+// Get returns the flag structure
+func (t *Timestamp) Get() interface{} {
+ return *t
+}
+
+// TimestampFlag is a flag with type time
+type TimestampFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Layout string
+ Value *Timestamp
+ DefaultText string
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *TimestampFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *TimestampFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *TimestampFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *TimestampFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *TimestampFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *TimestampFlag) GetUsage() string {
+ return f.Usage
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *TimestampFlag) GetValue() string {
+ if f.Value != nil {
+ return f.Value.timestamp.String()
+ }
+ return ""
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *TimestampFlag) Apply(set *flag.FlagSet) error {
+ if f.Layout == "" {
+ return fmt.Errorf("timestamp Layout is required")
+ }
+ f.Value = &Timestamp{}
+ f.Value.SetLayout(f.Layout)
+
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if err := f.Value.Set(val); err != nil {
+ return fmt.Errorf("could not parse %q as timestamp value for flag %s: %s", val, f.Name, err)
+ }
+ f.HasBeenSet = true
+ }
+
+ for _, name := range f.Names() {
+ set.Var(f.Value, name, f.Usage)
+ }
+ return nil
+}
+
+// Timestamp gets the timestamp from a flag name
+func (c *Context) Timestamp(name string) *time.Time {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupTimestamp(name, fs)
+ }
+ return nil
+}
+
+// Fetches the timestamp value from the local timestampWrap
+func lookupTimestamp(name string, set *flag.FlagSet) *time.Time {
+ f := set.Lookup(name)
+ if f != nil {
+ return (f.Value.(*Timestamp)).Value()
+ }
+ return nil
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_uint.go b/vendor/github.com/urfave/cli/v2/flag_uint.go
new file mode 100644
index 0000000000000..9f592388fe92c
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_uint.go
@@ -0,0 +1,105 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "strconv"
+)
+
+// UintFlag is a flag with type uint
+type UintFlag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value uint
+ DefaultText string
+ Destination *uint
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *UintFlag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *UintFlag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *UintFlag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *UintFlag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *UintFlag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *UintFlag) GetUsage() string {
+ return f.Usage
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *UintFlag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ valInt, err := strconv.ParseUint(val, 0, 64)
+ if err != nil {
+ return fmt.Errorf("could not parse %q as uint value for flag %s: %s", val, f.Name, err)
+ }
+
+ f.Value = uint(valInt)
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.UintVar(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.Uint(name, f.Value, f.Usage)
+ }
+
+ return nil
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *UintFlag) GetValue() string {
+ return fmt.Sprintf("%d", f.Value)
+}
+
+// Uint looks up the value of a local UintFlag, returns
+// 0 if not found
+func (c *Context) Uint(name string) uint {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupUint(name, fs)
+ }
+ return 0
+}
+
+func lookupUint(name string, set *flag.FlagSet) uint {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
+ if err != nil {
+ return 0
+ }
+ return uint(parsed)
+ }
+ return 0
+}
diff --git a/vendor/github.com/urfave/cli/v2/flag_uint64.go b/vendor/github.com/urfave/cli/v2/flag_uint64.go
new file mode 100644
index 0000000000000..5bbd1fa4b9ce7
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/flag_uint64.go
@@ -0,0 +1,105 @@
+package cli
+
+import (
+ "flag"
+ "fmt"
+ "strconv"
+)
+
+// Uint64Flag is a flag with type uint64
+type Uint64Flag struct {
+ Name string
+ Aliases []string
+ Usage string
+ EnvVars []string
+ FilePath string
+ Required bool
+ Hidden bool
+ Value uint64
+ DefaultText string
+ Destination *uint64
+ HasBeenSet bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Uint64Flag) IsSet() bool {
+ return f.HasBeenSet
+}
+
+// String returns a readable representation of this value
+// (for usage defaults)
+func (f *Uint64Flag) String() string {
+ return FlagStringer(f)
+}
+
+// Names returns the names of the flag
+func (f *Uint64Flag) Names() []string {
+ return flagNames(f)
+}
+
+// IsRequired returns whether or not the flag is required
+func (f *Uint64Flag) IsRequired() bool {
+ return f.Required
+}
+
+// TakesValue returns true of the flag takes a value, otherwise false
+func (f *Uint64Flag) TakesValue() bool {
+ return true
+}
+
+// GetUsage returns the usage string for the flag
+func (f *Uint64Flag) GetUsage() string {
+ return f.Usage
+}
+
+// Apply populates the flag given the flag set and environment
+func (f *Uint64Flag) Apply(set *flag.FlagSet) error {
+ if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
+ if val != "" {
+ valInt, err := strconv.ParseUint(val, 0, 64)
+ if err != nil {
+ return fmt.Errorf("could not parse %q as uint64 value for flag %s: %s", val, f.Name, err)
+ }
+
+ f.Value = valInt
+ f.HasBeenSet = true
+ }
+ }
+
+ for _, name := range f.Names() {
+ if f.Destination != nil {
+ set.Uint64Var(f.Destination, name, f.Value, f.Usage)
+ continue
+ }
+ set.Uint64(name, f.Value, f.Usage)
+ }
+
+ return nil
+}
+
+// GetValue returns the flags value as string representation and an empty
+// string if the flag takes no value at all.
+func (f *Uint64Flag) GetValue() string {
+ return fmt.Sprintf("%d", f.Value)
+}
+
+// Uint64 looks up the value of a local Uint64Flag, returns
+// 0 if not found
+func (c *Context) Uint64(name string) uint64 {
+ if fs := lookupFlagSet(name, c); fs != nil {
+ return lookupUint64(name, fs)
+ }
+ return 0
+}
+
+func lookupUint64(name string, set *flag.FlagSet) uint64 {
+ f := set.Lookup(name)
+ if f != nil {
+ parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
+ if err != nil {
+ return 0
+ }
+ return parsed
+ }
+ return 0
+}
diff --git a/vendor/github.com/urfave/cli/v2/funcs.go b/vendor/github.com/urfave/cli/v2/funcs.go
new file mode 100644
index 0000000000000..474c48faf9286
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/funcs.go
@@ -0,0 +1,44 @@
+package cli
+
+// BashCompleteFunc is an action to execute when the shell completion flag is set
+type BashCompleteFunc func(*Context)
+
+// BeforeFunc is an action to execute before any subcommands are run, but after
+// the context is ready if a non-nil error is returned, no subcommands are run
+type BeforeFunc func(*Context) error
+
+// AfterFunc is an action to execute after any subcommands are run, but after the
+// subcommand has finished it is run even if Action() panics
+type AfterFunc func(*Context) error
+
+// ActionFunc is the action to execute when no subcommands are specified
+type ActionFunc func(*Context) error
+
+// CommandNotFoundFunc is executed if the proper command cannot be found
+type CommandNotFoundFunc func(*Context, string)
+
+// OnUsageErrorFunc is executed if an usage error occurs. This is useful for displaying
+// customized usage error messages. This function is able to replace the
+// original error messages. If this function is not set, the "Incorrect usage"
+// is displayed and the execution is interrupted.
+type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error
+
+// ExitErrHandlerFunc is executed if provided in order to handle exitError values
+// returned by Actions and Before/After functions.
+type ExitErrHandlerFunc func(context *Context, err error)
+
+// FlagStringFunc is used by the help generation to display a flag, which is
+// expected to be a single line.
+type FlagStringFunc func(Flag) string
+
+// FlagNamePrefixFunc is used by the default FlagStringFunc to create prefix
+// text for a flag's full name.
+type FlagNamePrefixFunc func(fullName []string, placeholder string) string
+
+// FlagEnvHintFunc is used by the default FlagStringFunc to annotate flag help
+// with the environment variable details.
+type FlagEnvHintFunc func(envVars []string, str string) string
+
+// FlagFileHintFunc is used by the default FlagStringFunc to annotate flag help
+// with the file path details.
+type FlagFileHintFunc func(filePath, str string) string
diff --git a/vendor/github.com/urfave/cli/v2/go.mod b/vendor/github.com/urfave/cli/v2/go.mod
new file mode 100644
index 0000000000000..c38d41c14ba30
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/go.mod
@@ -0,0 +1,9 @@
+module github.com/urfave/cli/v2
+
+go 1.11
+
+require (
+ github.com/BurntSushi/toml v0.3.1
+ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d
+ gopkg.in/yaml.v2 v2.2.2
+)
diff --git a/vendor/github.com/urfave/cli/v2/go.sum b/vendor/github.com/urfave/cli/v2/go.sum
new file mode 100644
index 0000000000000..ef121ff5dbb84
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/go.sum
@@ -0,0 +1,14 @@
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d h1:U+s90UTSYgptZMwQh2aRr3LuazLJIa+Pg3Kc1ylSYVY=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
diff --git a/vendor/github.com/urfave/cli/v2/help.go b/vendor/github.com/urfave/cli/v2/help.go
new file mode 100644
index 0000000000000..c1e974a48112f
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/help.go
@@ -0,0 +1,368 @@
+package cli
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "strings"
+ "text/tabwriter"
+ "text/template"
+ "unicode/utf8"
+)
+
+var helpCommand = &Command{
+ Name: "help",
+ Aliases: []string{"h"},
+ Usage: "Shows a list of commands or help for one command",
+ ArgsUsage: "[command]",
+ Action: func(c *Context) error {
+ args := c.Args()
+ if args.Present() {
+ return ShowCommandHelp(c, args.First())
+ }
+
+ _ = ShowAppHelp(c)
+ return nil
+ },
+}
+
+var helpSubcommand = &Command{
+ Name: "help",
+ Aliases: []string{"h"},
+ Usage: "Shows a list of commands or help for one command",
+ ArgsUsage: "[command]",
+ Action: func(c *Context) error {
+ args := c.Args()
+ if args.Present() {
+ return ShowCommandHelp(c, args.First())
+ }
+
+ return ShowSubcommandHelp(c)
+ },
+}
+
+// Prints help for the App or Command
+type helpPrinter func(w io.Writer, templ string, data interface{})
+
+// Prints help for the App or Command with custom template function.
+type helpPrinterCustom func(w io.Writer, templ string, data interface{}, customFunc map[string]interface{})
+
+// HelpPrinter is a function that writes the help output. If not set explicitly,
+// this calls HelpPrinterCustom using only the default template functions.
+//
+// If custom logic for printing help is required, this function can be
+// overridden. If the ExtraInfo field is defined on an App, this function
+// should not be modified, as HelpPrinterCustom will be used directly in order
+// to capture the extra information.
+var HelpPrinter helpPrinter = printHelp
+
+// HelpPrinterCustom is a function that writes the help output. It is used as
+// the default implementation of HelpPrinter, and may be called directly if
+// the ExtraInfo field is set on an App.
+var HelpPrinterCustom helpPrinterCustom = printHelpCustom
+
+// VersionPrinter prints the version for the App
+var VersionPrinter = printVersion
+
+// ShowAppHelpAndExit - Prints the list of subcommands for the app and exits with exit code.
+func ShowAppHelpAndExit(c *Context, exitCode int) {
+ _ = ShowAppHelp(c)
+ os.Exit(exitCode)
+}
+
+// ShowAppHelp is an action that displays the help.
+func ShowAppHelp(c *Context) error {
+ template := c.App.CustomAppHelpTemplate
+ if template == "" {
+ template = AppHelpTemplate
+ }
+
+ if c.App.ExtraInfo == nil {
+ HelpPrinter(c.App.Writer, template, c.App)
+ return nil
+ }
+
+ customAppData := func() map[string]interface{} {
+ return map[string]interface{}{
+ "ExtraInfo": c.App.ExtraInfo,
+ }
+ }
+ HelpPrinterCustom(c.App.Writer, template, c.App, customAppData())
+
+ return nil
+}
+
+// DefaultAppComplete prints the list of subcommands as the default app completion method
+func DefaultAppComplete(c *Context) {
+ DefaultCompleteWithFlags(nil)(c)
+}
+
+func printCommandSuggestions(commands []*Command, writer io.Writer) {
+ for _, command := range commands {
+ if command.Hidden {
+ continue
+ }
+ if os.Getenv("_CLI_ZSH_AUTOCOMPLETE_HACK") == "1" {
+ for _, name := range command.Names() {
+ _, _ = fmt.Fprintf(writer, "%s:%s\n", name, command.Usage)
+ }
+ } else {
+ for _, name := range command.Names() {
+ _, _ = fmt.Fprintf(writer, "%s\n", name)
+ }
+ }
+ }
+}
+
+func cliArgContains(flagName string) bool {
+ for _, name := range strings.Split(flagName, ",") {
+ name = strings.TrimSpace(name)
+ count := utf8.RuneCountInString(name)
+ if count > 2 {
+ count = 2
+ }
+ flag := fmt.Sprintf("%s%s", strings.Repeat("-", count), name)
+ for _, a := range os.Args {
+ if a == flag {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+func printFlagSuggestions(lastArg string, flags []Flag, writer io.Writer) {
+ cur := strings.TrimPrefix(lastArg, "-")
+ cur = strings.TrimPrefix(cur, "-")
+ for _, flag := range flags {
+ if bflag, ok := flag.(*BoolFlag); ok && bflag.Hidden {
+ continue
+ }
+ for _, name := range flag.Names() {
+ name = strings.TrimSpace(name)
+ // this will get total count utf8 letters in flag name
+ count := utf8.RuneCountInString(name)
+ if count > 2 {
+ count = 2 // resuse this count to generate single - or -- in flag completion
+ }
+ // if flag name has more than one utf8 letter and last argument in cli has -- prefix then
+ // skip flag completion for short flags example -v or -x
+ if strings.HasPrefix(lastArg, "--") && count == 1 {
+ continue
+ }
+ // match if last argument matches this flag and it is not repeated
+ if strings.HasPrefix(name, cur) && cur != name && !cliArgContains(name) {
+ flagCompletion := fmt.Sprintf("%s%s", strings.Repeat("-", count), name)
+ _, _ = fmt.Fprintln(writer, flagCompletion)
+ }
+ }
+ }
+}
+
+func DefaultCompleteWithFlags(cmd *Command) func(c *Context) {
+ return func(c *Context) {
+ if len(os.Args) > 2 {
+ lastArg := os.Args[len(os.Args)-2]
+ if strings.HasPrefix(lastArg, "-") {
+ printFlagSuggestions(lastArg, c.App.Flags, c.App.Writer)
+ if cmd != nil {
+ printFlagSuggestions(lastArg, cmd.Flags, c.App.Writer)
+ }
+ return
+ }
+ }
+ if cmd != nil {
+ printCommandSuggestions(cmd.Subcommands, c.App.Writer)
+ } else {
+ printCommandSuggestions(c.App.Commands, c.App.Writer)
+ }
+ }
+}
+
+// ShowCommandHelpAndExit - exits with code after showing help
+func ShowCommandHelpAndExit(c *Context, command string, code int) {
+ _ = ShowCommandHelp(c, command)
+ os.Exit(code)
+}
+
+// ShowCommandHelp prints help for the given command
+func ShowCommandHelp(ctx *Context, command string) error {
+ // show the subcommand help for a command with subcommands
+ if command == "" {
+ HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
+ return nil
+ }
+
+ for _, c := range ctx.App.Commands {
+ if c.HasName(command) {
+ templ := c.CustomHelpTemplate
+ if templ == "" {
+ templ = CommandHelpTemplate
+ }
+
+ HelpPrinter(ctx.App.Writer, templ, c)
+
+ return nil
+ }
+ }
+
+ if ctx.App.CommandNotFound == nil {
+ return Exit(fmt.Sprintf("No help topic for '%v'", command), 3)
+ }
+
+ ctx.App.CommandNotFound(ctx, command)
+ return nil
+}
+
+// ShowSubcommandHelp prints help for the given subcommand
+func ShowSubcommandHelp(c *Context) error {
+ if c == nil {
+ return nil
+ }
+
+ if c.Command != nil {
+ return ShowCommandHelp(c, c.Command.Name)
+ }
+
+ return ShowCommandHelp(c, "")
+}
+
+// ShowVersion prints the version number of the App
+func ShowVersion(c *Context) {
+ VersionPrinter(c)
+}
+
+func printVersion(c *Context) {
+ _, _ = fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
+}
+
+// ShowCompletions prints the lists of commands within a given context
+func ShowCompletions(c *Context) {
+ a := c.App
+ if a != nil && a.BashComplete != nil {
+ a.BashComplete(c)
+ }
+}
+
+// ShowCommandCompletions prints the custom completions for a given command
+func ShowCommandCompletions(ctx *Context, command string) {
+ c := ctx.App.Command(command)
+ if c != nil {
+ if c.BashComplete != nil {
+ c.BashComplete(ctx)
+ } else {
+ DefaultCompleteWithFlags(c)(ctx)
+ }
+ }
+
+}
+
+// printHelpCustom is the default implementation of HelpPrinterCustom.
+//
+// The customFuncs map will be combined with a default template.FuncMap to
+// allow using arbitrary functions in template rendering.
+func printHelpCustom(out io.Writer, templ string, data interface{}, customFuncs map[string]interface{}) {
+ funcMap := template.FuncMap{
+ "join": strings.Join,
+ }
+ for key, value := range customFuncs {
+ funcMap[key] = value
+ }
+
+ w := tabwriter.NewWriter(out, 1, 8, 2, ' ', 0)
+ t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
+
+ err := t.Execute(w, data)
+ if err != nil {
+ // If the writer is closed, t.Execute will fail, and there's nothing
+ // we can do to recover.
+ if os.Getenv("CLI_TEMPLATE_ERROR_DEBUG") != "" {
+ _, _ = fmt.Fprintf(ErrWriter, "CLI TEMPLATE ERROR: %#v\n", err)
+ }
+ return
+ }
+ _ = w.Flush()
+}
+
+func printHelp(out io.Writer, templ string, data interface{}) {
+ HelpPrinterCustom(out, templ, data, nil)
+}
+
+func checkVersion(c *Context) bool {
+ found := false
+ for _, name := range VersionFlag.Names() {
+ if c.Bool(name) {
+ found = true
+ }
+ }
+ return found
+}
+
+func checkHelp(c *Context) bool {
+ found := false
+ for _, name := range HelpFlag.Names() {
+ if c.Bool(name) {
+ found = true
+ }
+ }
+ return found
+}
+
+func checkCommandHelp(c *Context, name string) bool {
+ if c.Bool("h") || c.Bool("help") {
+ _ = ShowCommandHelp(c, name)
+ return true
+ }
+
+ return false
+}
+
+func checkSubcommandHelp(c *Context) bool {
+ if c.Bool("h") || c.Bool("help") {
+ _ = ShowSubcommandHelp(c)
+ return true
+ }
+
+ return false
+}
+
+func checkShellCompleteFlag(a *App, arguments []string) (bool, []string) {
+ if !a.EnableBashCompletion {
+ return false, arguments
+ }
+
+ pos := len(arguments) - 1
+ lastArg := arguments[pos]
+
+ if lastArg != "--generate-bash-completion" {
+ return false, arguments
+ }
+
+ return true, arguments[:pos]
+}
+
+func checkCompletions(c *Context) bool {
+ if !c.shellComplete {
+ return false
+ }
+
+ if args := c.Args(); args.Present() {
+ name := args.First()
+ if cmd := c.App.Command(name); cmd != nil {
+ // let the command handle the completion
+ return false
+ }
+ }
+
+ ShowCompletions(c)
+ return true
+}
+
+func checkCommandCompletions(c *Context, name string) bool {
+ if !c.shellComplete {
+ return false
+ }
+
+ ShowCommandCompletions(c, name)
+ return true
+}
diff --git a/vendor/github.com/urfave/cli/v2/parse.go b/vendor/github.com/urfave/cli/v2/parse.go
new file mode 100644
index 0000000000000..7df17296a4217
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/parse.go
@@ -0,0 +1,94 @@
+package cli
+
+import (
+ "flag"
+ "strings"
+)
+
+type iterativeParser interface {
+ newFlagSet() (*flag.FlagSet, error)
+ useShortOptionHandling() bool
+}
+
+// To enable short-option handling (e.g., "-it" vs "-i -t") we have to
+// iteratively catch parsing errors. This way we achieve LR parsing without
+// transforming any arguments. Otherwise, there is no way we can discriminate
+// combined short options from common arguments that should be left untouched.
+// Pass `shellComplete` to continue parsing options on failure during shell
+// completion when, the user-supplied options may be incomplete.
+func parseIter(set *flag.FlagSet, ip iterativeParser, args []string, shellComplete bool) error {
+ for {
+ err := set.Parse(args)
+ if !ip.useShortOptionHandling() || err == nil {
+ if shellComplete {
+ return nil
+ }
+ return err
+ }
+
+ errStr := err.Error()
+ trimmed := strings.TrimPrefix(errStr, "flag provided but not defined: -")
+ if errStr == trimmed {
+ return err
+ }
+
+ // regenerate the initial args with the split short opts
+ argsWereSplit := false
+ for i, arg := range args {
+ // skip args that are not part of the error message
+ if name := strings.TrimLeft(arg, "-"); name != trimmed {
+ continue
+ }
+
+ // if we can't split, the error was accurate
+ shortOpts := splitShortOptions(set, arg)
+ if len(shortOpts) == 1 {
+ return err
+ }
+
+ // swap current argument with the split version
+ args = append(args[:i], append(shortOpts, args[i+1:]...)...)
+ argsWereSplit = true
+ break
+ }
+
+ // This should be an impossible to reach code path, but in case the arg
+ // splitting failed to happen, this will prevent infinite loops
+ if !argsWereSplit {
+ return err
+ }
+
+ // Since custom parsing failed, replace the flag set before retrying
+ newSet, err := ip.newFlagSet()
+ if err != nil {
+ return err
+ }
+ *set = *newSet
+ }
+}
+
+func splitShortOptions(set *flag.FlagSet, arg string) []string {
+ shortFlagsExist := func(s string) bool {
+ for _, c := range s[1:] {
+ if f := set.Lookup(string(c)); f == nil {
+ return false
+ }
+ }
+ return true
+ }
+
+ if !isSplittable(arg) || !shortFlagsExist(arg) {
+ return []string{arg}
+ }
+
+ separated := make([]string, 0, len(arg)-1)
+ for _, flagChar := range arg[1:] {
+ separated = append(separated, "-"+string(flagChar))
+ }
+
+ return separated
+}
+
+func isSplittable(flagArg string) bool {
+ return strings.HasPrefix(flagArg, "-") && !strings.HasPrefix(flagArg, "--") && len(flagArg) > 2
+}
diff --git a/vendor/github.com/urfave/cli/v2/sort.go b/vendor/github.com/urfave/cli/v2/sort.go
new file mode 100644
index 0000000000000..23d1c2f772071
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/sort.go
@@ -0,0 +1,29 @@
+package cli
+
+import "unicode"
+
+// lexicographicLess compares strings alphabetically considering case.
+func lexicographicLess(i, j string) bool {
+ iRunes := []rune(i)
+ jRunes := []rune(j)
+
+ lenShared := len(iRunes)
+ if lenShared > len(jRunes) {
+ lenShared = len(jRunes)
+ }
+
+ for index := 0; index < lenShared; index++ {
+ ir := iRunes[index]
+ jr := jRunes[index]
+
+ if lir, ljr := unicode.ToLower(ir), unicode.ToLower(jr); lir != ljr {
+ return lir < ljr
+ }
+
+ if ir != jr {
+ return ir < jr
+ }
+ }
+
+ return i < j
+}
diff --git a/vendor/github.com/urfave/cli/v2/template.go b/vendor/github.com/urfave/cli/v2/template.go
new file mode 100644
index 0000000000000..1cc4bd624bd71
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v2/template.go
@@ -0,0 +1,119 @@
+package cli
+
+// AppHelpTemplate is the text template for the Default help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var AppHelpTemplate = `NAME:
+ {{.Name}}{{if .Usage}} - {{.Usage}}{{end}}
+
+USAGE:
+ {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} {{if .VisibleFlags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Version}}{{if not .HideVersion}}
+
+VERSION:
+ {{.Version}}{{end}}{{end}}{{if .Description}}
+
+DESCRIPTION:
+ {{.Description}}{{end}}{{if len .Authors}}
+
+AUTHOR{{with $length := len .Authors}}{{if ne 1 $length}}S{{end}}{{end}}:
+ {{range $index, $author := .Authors}}{{if $index}}
+ {{end}}{{$author}}{{end}}{{end}}{{if .VisibleCommands}}
+
+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
+ {{.Name}}:{{range .VisibleCommands}}
+ {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{else}}{{range .VisibleCommands}}
+ {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
+
+GLOBAL OPTIONS:
+ {{range $index, $option := .VisibleFlags}}{{if $index}}
+ {{end}}{{$option}}{{end}}{{end}}{{if .Copyright}}
+
+COPYRIGHT:
+ {{.Copyright}}{{end}}
+`
+
+// CommandHelpTemplate is the text template for the command help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var CommandHelpTemplate = `NAME:
+ {{.HelpName}} - {{.Usage}}
+
+USAGE:
+ {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}}{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}{{if .Category}}
+
+CATEGORY:
+ {{.Category}}{{end}}{{if .Description}}
+
+DESCRIPTION:
+ {{.Description}}{{end}}{{if .VisibleFlags}}
+
+OPTIONS:
+ {{range .VisibleFlags}}{{.}}
+ {{end}}{{end}}
+`
+
+// SubcommandHelpTemplate is the text template for the subcommand help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var SubcommandHelpTemplate = `NAME:
+ {{.HelpName}} - {{if .Description}}{{.Description}}{{else}}{{.Usage}}{{end}}
+
+USAGE:
+ {{if .UsageText}}{{.UsageText}}{{else}}{{.HelpName}} command{{if .VisibleFlags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{end}}
+
+COMMANDS:{{range .VisibleCategories}}{{if .Name}}
+ {{.Name}}:{{range .VisibleCommands}}
+ {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{else}}{{range .VisibleCommands}}
+ {{join .Names ", "}}{{"\t"}}{{.Usage}}{{end}}{{end}}{{end}}{{if .VisibleFlags}}
+
+OPTIONS:
+ {{range .VisibleFlags}}{{.}}
+ {{end}}{{end}}
+`
+
+var MarkdownDocTemplate = `% {{ .App.Name }}(8){{ if .App.Description }} {{ .App.Description }}{{ end }}
+{{ range $a := .App.Authors }}
+% {{ $a }}{{ end }}
+
+# NAME
+
+{{ .App.Name }}{{ if .App.Usage }} - {{ .App.Usage }}{{ end }}
+
+# SYNOPSIS
+
+{{ .App.Name }}
+{{ if .SynopsisArgs }}
+` + "```" + `
+{{ range $v := .SynopsisArgs }}{{ $v }}{{ end }}` + "```" + `
+{{ end }}{{ if .App.UsageText }}
+# DESCRIPTION
+
+{{ .App.UsageText }}
+{{ end }}
+**Usage**:
+
+` + "```" + `
+{{ .App.Name }} [GLOBAL OPTIONS] command [COMMAND OPTIONS] [ARGUMENTS...]
+` + "```" + `
+{{ if .GlobalArgs }}
+# GLOBAL OPTIONS
+{{ range $v := .GlobalArgs }}
+{{ $v }}{{ end }}
+{{ end }}{{ if .Commands }}
+# COMMANDS
+{{ range $v := .Commands }}
+{{ $v }}{{ end }}{{ end }}`
+
+var FishCompletionTemplate = `# {{ .App.Name }} fish shell completion
+
+function __fish_{{ .App.Name }}_no_subcommand --description 'Test if there has been any subcommand yet'
+ for i in (commandline -opc)
+ if contains -- $i{{ range $v := .AllCommands }} {{ $v }}{{ end }}
+ return 1
+ end
+ end
+ return 0
+end
+
+{{ range $v := .Completions }}{{ $v }}
+{{ end }}`
diff --git a/vendor/github.com/vektah/dataloaden/.gitignore b/vendor/github.com/vektah/dataloaden/.gitignore
new file mode 100644
index 0000000000000..40b341e351837
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/.gitignore
@@ -0,0 +1,2 @@
+/vendor
+/.idea
\ No newline at end of file
diff --git a/vendor/github.com/vektah/dataloaden/README.md b/vendor/github.com/vektah/dataloaden/README.md
new file mode 100644
index 0000000000000..f5bcb917ef249
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/README.md
@@ -0,0 +1,97 @@
+### The DATALOADer gENerator [](https://circleci.com/gh/vektah/dataloaden) [](https://goreportcard.com/report/github.com/vektah/dataloaden) [](https://codecov.io/gh/vektah/dataloaden)
+
+Requires golang 1.11+ for modules support.
+
+This is a tool for generating type safe data loaders for go, inspired by https://github.com/facebook/dataloader.
+
+The intended use is in graphql servers, to reduce the number of queries being sent to the database. These dataloader
+objects should be request scoped and short lived. They should be cheap to create in every request even if they dont
+get used.
+
+#### Getting started
+
+From inside the package you want to have the dataloader in:
+```bash
+go run github.com/vektah/dataloaden UserLoader string *github.com/dataloaden/example.User
+```
+
+This will generate a dataloader called `UserLoader` that looks up `*github.com/dataloaden/example.User`'s objects
+based on a `string` key.
+
+In another file in the same package, create the constructor method:
+```go
+func NewUserLoader() *UserLoader {
+ return &UserLoader{
+ wait: 2 * time.Millisecond,
+ maxBatch: 100,
+ fetch: func(keys []string) ([]*User, []error) {
+ users := make([]*User, len(keys))
+ errors := make([]error, len(keys))
+
+ for i, key := range keys {
+ users[i] = &User{ID: key, Name: "user " + key}
+ }
+ return users, errors
+ },
+ }
+}
+```
+
+Then wherever you want to call the dataloader
+```go
+loader := NewUserLoader()
+
+user, err := loader.Load("123")
+```
+
+This method will block for a short amount of time, waiting for any other similar requests to come in, call your fetch
+function once. It also caches values and wont request duplicates in a batch.
+
+#### Returning Slices
+
+You may want to generate a dataloader that returns slices instead of single values. Both key and value types can be a
+simple go type expression:
+
+```bash
+go run github.com/vektah/dataloaden UserSliceLoader string []*github.com/dataloaden/example.User
+```
+
+Now each key is expected to return a slice of values and the `fetch` function has the return type `[][]*User`.
+
+#### Using with go modules
+
+Create a tools.go that looks like this:
+```go
+// +build tools
+
+package main
+
+import _ "github.com/vektah/dataloaden"
+```
+
+This will allow go modules to see the dependency.
+
+You can invoke it from anywhere within your module now using `go run github.com/vektah/dataloaden` and
+always get the pinned version.
+
+#### Wait, how do I use context with this?
+
+I don't think context makes sense to be passed through a data loader. Consider a few scenarios:
+1. a dataloader shared between requests: request A and B both get batched together, which context should be passed to the DB? context.Background is probably more suitable.
+2. a dataloader per request for graphql: two different nodes in the graph get batched together, they have different context for tracing purposes, which should be passed to the db? neither, you should just use the root request context.
+
+
+So be explicit about your context:
+```go
+func NewLoader(ctx context.Context) *UserLoader {
+ return &UserLoader{
+ wait: 2 * time.Millisecond,
+ maxBatch: 100,
+ fetch: func(keys []string) ([]*User, []error) {
+ // you now have a ctx to work with
+ },
+ }
+}
+```
+
+If you feel like I'm wrong please raise an issue.
diff --git a/vendor/github.com/vektah/dataloaden/appveyor.yml b/vendor/github.com/vektah/dataloaden/appveyor.yml
new file mode 100644
index 0000000000000..ee3ff895d8fbb
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/appveyor.yml
@@ -0,0 +1,32 @@
+version: "{build}"
+
+# Source Config
+
+skip_branch_with_pr: true
+clone_folder: c:\projects\dataloaden
+
+# Build host
+
+environment:
+ GOPATH: c:\gopath
+ GOVERSION: 1.11.5
+ PATH: '%PATH%;c:\gopath\bin'
+
+init:
+ - git config --global core.autocrlf input
+
+# Build
+
+install:
+ # Install the specific Go version.
+ - rmdir c:\go /s /q
+ - appveyor DownloadFile https://storage.googleapis.com/golang/go%GOVERSION%.windows-amd64.msi
+ - msiexec /i go%GOVERSION%.windows-amd64.msi /q
+ - go version
+
+build: false
+deploy: false
+
+test_script:
+ - go generate ./...
+ - go test -parallel 8 ./...
diff --git a/vendor/github.com/vektah/dataloaden/dataloaden.go b/vendor/github.com/vektah/dataloaden/dataloaden.go
new file mode 100644
index 0000000000000..3419286d522f9
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/dataloaden.go
@@ -0,0 +1,28 @@
+package main
+
+import (
+ "fmt"
+ "os"
+
+ "github.com/vektah/dataloaden/pkg/generator"
+)
+
+func main() {
+ if len(os.Args) != 4 {
+ fmt.Println("usage: name keyType valueType")
+ fmt.Println(" example:")
+ fmt.Println(" dataloaden 'UserLoader int []*github.com/my/package.User'")
+ os.Exit(1)
+ }
+
+ wd, err := os.Getwd()
+ if err != nil {
+ fmt.Fprintln(os.Stderr, err.Error())
+ os.Exit(2)
+ }
+
+ if err := generator.Generate(os.Args[1], os.Args[2], os.Args[3], wd); err != nil {
+ fmt.Fprintln(os.Stderr, err.Error())
+ os.Exit(2)
+ }
+}
diff --git a/vendor/github.com/vektah/dataloaden/go.mod b/vendor/github.com/vektah/dataloaden/go.mod
new file mode 100644
index 0000000000000..ba56ca03df913
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/go.mod
@@ -0,0 +1,9 @@
+module github.com/vektah/dataloaden
+
+require (
+ github.com/davecgh/go-spew v1.1.0 // indirect
+ github.com/pkg/errors v0.8.1
+ github.com/pmezard/go-difflib v1.0.0 // indirect
+ github.com/stretchr/testify v1.2.1
+ golang.org/x/tools v0.0.0-20190515012406-7d7faa4812bd
+)
diff --git a/vendor/github.com/vektah/dataloaden/go.sum b/vendor/github.com/vektah/dataloaden/go.sum
new file mode 100644
index 0000000000000..a350afb0a9adc
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/go.sum
@@ -0,0 +1,15 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.2.1 h1:52QO5WkIUcHGIR7EnGagH88x1bUzqGXTC5/1bDTUQ7U=
+github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20190515012406-7d7faa4812bd h1:oMEQDWVXVNpceQoVd1JN3CQ7LYJJzs5qWqZIUcxXHHw=
+golang.org/x/tools v0.0.0-20190515012406-7d7faa4812bd/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
diff --git a/vendor/github.com/vektah/dataloaden/licence.md b/vendor/github.com/vektah/dataloaden/licence.md
new file mode 100644
index 0000000000000..e47379a15dd29
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/licence.md
@@ -0,0 +1,7 @@
+Copyright (c) 2017 Adam Scarr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/vendor/github.com/vektah/dataloaden/pkg/generator/generator.go b/vendor/github.com/vektah/dataloaden/pkg/generator/generator.go
new file mode 100644
index 0000000000000..ff618e7b358ad
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/pkg/generator/generator.go
@@ -0,0 +1,163 @@
+package generator
+
+import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "path/filepath"
+ "regexp"
+ "strings"
+ "unicode"
+
+ "github.com/pkg/errors"
+ "golang.org/x/tools/go/packages"
+ "golang.org/x/tools/imports"
+)
+
+type templateData struct {
+ Package string
+ Name string
+ KeyType *goType
+ ValType *goType
+}
+
+type goType struct {
+ Modifiers string
+ ImportPath string
+ ImportName string
+ Name string
+}
+
+func (t *goType) String() string {
+ if t.ImportName != "" {
+ return t.Modifiers + t.ImportName + "." + t.Name
+ }
+
+ return t.Modifiers + t.Name
+}
+
+func (t *goType) IsPtr() bool {
+ return strings.HasPrefix(t.Modifiers, "*")
+}
+
+func (t *goType) IsSlice() bool {
+ return strings.HasPrefix(t.Modifiers, "[]")
+}
+
+var partsRe = regexp.MustCompile(`^([\[\]\*]*)(.*?)(\.\w*)?$`)
+
+func parseType(str string) (*goType, error) {
+ parts := partsRe.FindStringSubmatch(str)
+ if len(parts) != 4 {
+ return nil, fmt.Errorf("type must be in the form []*github.com/import/path.Name")
+ }
+
+ t := &goType{
+ Modifiers: parts[1],
+ ImportPath: parts[2],
+ Name: strings.TrimPrefix(parts[3], "."),
+ }
+
+ if t.Name == "" {
+ t.Name = t.ImportPath
+ t.ImportPath = ""
+ }
+
+ if t.ImportPath != "" {
+ p, err := packages.Load(&packages.Config{Mode: packages.NeedName}, t.ImportPath)
+ if err != nil {
+ return nil, err
+ }
+ if len(p) != 1 {
+ return nil, fmt.Errorf("not found")
+ }
+
+ t.ImportName = p[0].Name
+ }
+
+ return t, nil
+}
+
+func Generate(name string, keyType string, valueType string, wd string) error {
+ data, err := getData(name, keyType, valueType, wd)
+ if err != nil {
+ return err
+ }
+
+ filename := strings.ToLower(data.Name) + "_gen.go"
+
+ if err := writeTemplate(filepath.Join(wd, filename), data); err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func getData(name string, keyType string, valueType string, wd string) (templateData, error) {
+ var data templateData
+
+ genPkg := getPackage(wd)
+ if genPkg == nil {
+ return templateData{}, fmt.Errorf("unable to find package info for " + wd)
+ }
+
+ var err error
+ data.Name = name
+ data.Package = genPkg.Name
+ data.KeyType, err = parseType(keyType)
+ if err != nil {
+ return templateData{}, fmt.Errorf("key type: %s", err.Error())
+ }
+ data.ValType, err = parseType(valueType)
+ if err != nil {
+ return templateData{}, fmt.Errorf("key type: %s", err.Error())
+ }
+
+ // if we are inside the same package as the type we don't need an import and can refer directly to the type
+ if genPkg.PkgPath == data.ValType.ImportPath {
+ data.ValType.ImportName = ""
+ data.ValType.ImportPath = ""
+ }
+ if genPkg.PkgPath == data.KeyType.ImportPath {
+ data.KeyType.ImportName = ""
+ data.KeyType.ImportPath = ""
+ }
+
+ return data, nil
+}
+
+func getPackage(dir string) *packages.Package {
+ p, _ := packages.Load(&packages.Config{
+ Dir: dir,
+ }, ".")
+
+ if len(p) != 1 {
+ return nil
+ }
+
+ return p[0]
+}
+
+func writeTemplate(filepath string, data templateData) error {
+ var buf bytes.Buffer
+ if err := tpl.Execute(&buf, data); err != nil {
+ return errors.Wrap(err, "generating code")
+ }
+
+ src, err := imports.Process(filepath, buf.Bytes(), nil)
+ if err != nil {
+ return errors.Wrap(err, "unable to gofmt")
+ }
+
+ if err := ioutil.WriteFile(filepath, src, 0644); err != nil {
+ return errors.Wrap(err, "writing output")
+ }
+
+ return nil
+}
+
+func lcFirst(s string) string {
+ r := []rune(s)
+ r[0] = unicode.ToLower(r[0])
+ return string(r)
+}
diff --git a/vendor/github.com/vektah/dataloaden/pkg/generator/template.go b/vendor/github.com/vektah/dataloaden/pkg/generator/template.go
new file mode 100644
index 0000000000000..48f5ba2522197
--- /dev/null
+++ b/vendor/github.com/vektah/dataloaden/pkg/generator/template.go
@@ -0,0 +1,245 @@
+package generator
+
+import "text/template"
+
+var tpl = template.Must(template.New("generated").
+ Funcs(template.FuncMap{
+ "lcFirst": lcFirst,
+ }).
+ Parse(`
+// Code generated by github.com/vektah/dataloaden, DO NOT EDIT.
+
+package {{.Package}}
+
+import (
+ "sync"
+ "time"
+
+ {{if .KeyType.ImportPath}}"{{.KeyType.ImportPath}}"{{end}}
+ {{if .ValType.ImportPath}}"{{.ValType.ImportPath}}"{{end}}
+)
+
+// {{.Name}}Config captures the config to create a new {{.Name}}
+type {{.Name}}Config struct {
+ // Fetch is a method that provides the data for the loader
+ Fetch func(keys []{{.KeyType.String}}) ([]{{.ValType.String}}, []error)
+
+ // Wait is how long wait before sending a batch
+ Wait time.Duration
+
+ // MaxBatch will limit the maximum number of keys to send in one batch, 0 = not limit
+ MaxBatch int
+}
+
+// New{{.Name}} creates a new {{.Name}} given a fetch, wait, and maxBatch
+func New{{.Name}}(config {{.Name}}Config) *{{.Name}} {
+ return &{{.Name}}{
+ fetch: config.Fetch,
+ wait: config.Wait,
+ maxBatch: config.MaxBatch,
+ }
+}
+
+// {{.Name}} batches and caches requests
+type {{.Name}} struct {
+ // this method provides the data for the loader
+ fetch func(keys []{{.KeyType.String}}) ([]{{.ValType.String}}, []error)
+
+ // how long to done before sending a batch
+ wait time.Duration
+
+ // this will limit the maximum number of keys to send in one batch, 0 = no limit
+ maxBatch int
+
+ // INTERNAL
+
+ // lazily created cache
+ cache map[{{.KeyType.String}}]{{.ValType.String}}
+
+ // the current batch. keys will continue to be collected until timeout is hit,
+ // then everything will be sent to the fetch method and out to the listeners
+ batch *{{.Name|lcFirst}}Batch
+
+ // mutex to prevent races
+ mu sync.Mutex
+}
+
+type {{.Name|lcFirst}}Batch struct {
+ keys []{{.KeyType}}
+ data []{{.ValType.String}}
+ error []error
+ closing bool
+ done chan struct{}
+}
+
+// Load a {{.ValType.Name}} by key, batching and caching will be applied automatically
+func (l *{{.Name}}) Load(key {{.KeyType.String}}) ({{.ValType.String}}, error) {
+ return l.LoadThunk(key)()
+}
+
+// LoadThunk returns a function that when called will block waiting for a {{.ValType.Name}}.
+// This method should be used if you want one goroutine to make requests to many
+// different data loaders without blocking until the thunk is called.
+func (l *{{.Name}}) LoadThunk(key {{.KeyType.String}}) func() ({{.ValType.String}}, error) {
+ l.mu.Lock()
+ if it, ok := l.cache[key]; ok {
+ l.mu.Unlock()
+ return func() ({{.ValType.String}}, error) {
+ return it, nil
+ }
+ }
+ if l.batch == nil {
+ l.batch = &{{.Name|lcFirst}}Batch{done: make(chan struct{})}
+ }
+ batch := l.batch
+ pos := batch.keyIndex(l, key)
+ l.mu.Unlock()
+
+ return func() ({{.ValType.String}}, error) {
+ <-batch.done
+
+ var data {{.ValType.String}}
+ if pos < len(batch.data) {
+ data = batch.data[pos]
+ }
+
+ var err error
+ // its convenient to be able to return a single error for everything
+ if len(batch.error) == 1 {
+ err = batch.error[0]
+ } else if batch.error != nil {
+ err = batch.error[pos]
+ }
+
+ if err == nil {
+ l.mu.Lock()
+ l.unsafeSet(key, data)
+ l.mu.Unlock()
+ }
+
+ return data, err
+ }
+}
+
+// LoadAll fetches many keys at once. It will be broken into appropriate sized
+// sub batches depending on how the loader is configured
+func (l *{{.Name}}) LoadAll(keys []{{.KeyType}}) ([]{{.ValType.String}}, []error) {
+ results := make([]func() ({{.ValType.String}}, error), len(keys))
+
+ for i, key := range keys {
+ results[i] = l.LoadThunk(key)
+ }
+
+ {{.ValType.Name|lcFirst}}s := make([]{{.ValType.String}}, len(keys))
+ errors := make([]error, len(keys))
+ for i, thunk := range results {
+ {{.ValType.Name|lcFirst}}s[i], errors[i] = thunk()
+ }
+ return {{.ValType.Name|lcFirst}}s, errors
+}
+
+// LoadAllThunk returns a function that when called will block waiting for a {{.ValType.Name}}s.
+// This method should be used if you want one goroutine to make requests to many
+// different data loaders without blocking until the thunk is called.
+func (l *{{.Name}}) LoadAllThunk(keys []{{.KeyType}}) (func() ([]{{.ValType.String}}, []error)) {
+ results := make([]func() ({{.ValType.String}}, error), len(keys))
+ for i, key := range keys {
+ results[i] = l.LoadThunk(key)
+ }
+ return func() ([]{{.ValType.String}}, []error) {
+ {{.ValType.Name|lcFirst}}s := make([]{{.ValType.String}}, len(keys))
+ errors := make([]error, len(keys))
+ for i, thunk := range results {
+ {{.ValType.Name|lcFirst}}s[i], errors[i] = thunk()
+ }
+ return {{.ValType.Name|lcFirst}}s, errors
+ }
+}
+
+// Prime the cache with the provided key and value. If the key already exists, no change is made
+// and false is returned.
+// (To forcefully prime the cache, clear the key first with loader.clear(key).prime(key, value).)
+func (l *{{.Name}}) Prime(key {{.KeyType}}, value {{.ValType.String}}) bool {
+ l.mu.Lock()
+ var found bool
+ if _, found = l.cache[key]; !found {
+ {{- if .ValType.IsPtr }}
+ // make a copy when writing to the cache, its easy to pass a pointer in from a loop var
+ // and end up with the whole cache pointing to the same value.
+ cpy := *value
+ l.unsafeSet(key, &cpy)
+ {{- else if .ValType.IsSlice }}
+ // make a copy when writing to the cache, its easy to pass a pointer in from a loop var
+ // and end up with the whole cache pointing to the same value.
+ cpy := make({{.ValType.String}}, len(value))
+ copy(cpy, value)
+ l.unsafeSet(key, cpy)
+ {{- else }}
+ l.unsafeSet(key, value)
+ {{- end }}
+ }
+ l.mu.Unlock()
+ return !found
+}
+
+// Clear the value at key from the cache, if it exists
+func (l *{{.Name}}) Clear(key {{.KeyType}}) {
+ l.mu.Lock()
+ delete(l.cache, key)
+ l.mu.Unlock()
+}
+
+func (l *{{.Name}}) unsafeSet(key {{.KeyType}}, value {{.ValType.String}}) {
+ if l.cache == nil {
+ l.cache = map[{{.KeyType}}]{{.ValType.String}}{}
+ }
+ l.cache[key] = value
+}
+
+// keyIndex will return the location of the key in the batch, if its not found
+// it will add the key to the batch
+func (b *{{.Name|lcFirst}}Batch) keyIndex(l *{{.Name}}, key {{.KeyType}}) int {
+ for i, existingKey := range b.keys {
+ if key == existingKey {
+ return i
+ }
+ }
+
+ pos := len(b.keys)
+ b.keys = append(b.keys, key)
+ if pos == 0 {
+ go b.startTimer(l)
+ }
+
+ if l.maxBatch != 0 && pos >= l.maxBatch-1 {
+ if !b.closing {
+ b.closing = true
+ l.batch = nil
+ go b.end(l)
+ }
+ }
+
+ return pos
+}
+
+func (b *{{.Name|lcFirst}}Batch) startTimer(l *{{.Name}}) {
+ time.Sleep(l.wait)
+ l.mu.Lock()
+
+ // we must have hit a batch limit and are already finalizing this batch
+ if b.closing {
+ l.mu.Unlock()
+ return
+ }
+
+ l.batch = nil
+ l.mu.Unlock()
+
+ b.end(l)
+}
+
+func (b *{{.Name|lcFirst}}Batch) end(l *{{.Name}}) {
+ b.data, b.error = l.fetch(b.keys)
+ close(b.done)
+}
+`))
diff --git a/vendor/github.com/vektah/gqlparser/v2/.gitignore b/vendor/github.com/vektah/gqlparser/v2/.gitignore
new file mode 100644
index 0000000000000..877392a7639ed
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/.gitignore
@@ -0,0 +1,5 @@
+/vendor
+/validator/imported/node_modules
+/validator/imported/graphql-js
+
+.idea/
diff --git a/vendor/github.com/vektah/gqlparser/v2/LICENSE b/vendor/github.com/vektah/gqlparser/v2/LICENSE
new file mode 100644
index 0000000000000..1221b9d3894f8
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2018 Adam Scarr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/argmap.go b/vendor/github.com/vektah/gqlparser/v2/ast/argmap.go
new file mode 100644
index 0000000000000..43f6a3d6fc6f9
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/argmap.go
@@ -0,0 +1,37 @@
+package ast
+
+func arg2map(defs ArgumentDefinitionList, args ArgumentList, vars map[string]interface{}) map[string]interface{} {
+ result := map[string]interface{}{}
+ var err error
+
+ for _, argDef := range defs {
+ var val interface{}
+ var hasValue bool
+
+ if argValue := args.ForName(argDef.Name); argValue != nil {
+ if argValue.Value.Kind == Variable {
+ val, hasValue = vars[argValue.Value.Raw]
+ } else {
+ val, err = argValue.Value.Value(vars)
+ if err != nil {
+ panic(err)
+ }
+ hasValue = true
+ }
+ }
+
+ if !hasValue && argDef.DefaultValue != nil {
+ val, err = argDef.DefaultValue.Value(vars)
+ if err != nil {
+ panic(err)
+ }
+ hasValue = true
+ }
+
+ if hasValue {
+ result[argDef.Name] = val
+ }
+ }
+
+ return result
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/collections.go b/vendor/github.com/vektah/gqlparser/v2/ast/collections.go
new file mode 100644
index 0000000000000..94b800ee260a7
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/collections.go
@@ -0,0 +1,148 @@
+package ast
+
+type FieldList []*FieldDefinition
+
+func (l FieldList) ForName(name string) *FieldDefinition {
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type EnumValueList []*EnumValueDefinition
+
+func (l EnumValueList) ForName(name string) *EnumValueDefinition {
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type DirectiveList []*Directive
+
+func (l DirectiveList) ForName(name string) *Directive {
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+func (l DirectiveList) ForNames(name string) []*Directive {
+ resp := []*Directive{}
+ for _, it := range l {
+ if it.Name == name {
+ resp = append(resp, it)
+ }
+ }
+ return resp
+}
+
+type OperationList []*OperationDefinition
+
+func (l OperationList) ForName(name string) *OperationDefinition {
+ if name == "" && len(l) == 1 {
+ return l[0]
+ }
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type FragmentDefinitionList []*FragmentDefinition
+
+func (l FragmentDefinitionList) ForName(name string) *FragmentDefinition {
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type VariableDefinitionList []*VariableDefinition
+
+func (l VariableDefinitionList) ForName(name string) *VariableDefinition {
+ for _, it := range l {
+ if it.Variable == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type ArgumentList []*Argument
+
+func (l ArgumentList) ForName(name string) *Argument {
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type ArgumentDefinitionList []*ArgumentDefinition
+
+func (l ArgumentDefinitionList) ForName(name string) *ArgumentDefinition {
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type SchemaDefinitionList []*SchemaDefinition
+
+type DirectiveDefinitionList []*DirectiveDefinition
+
+func (l DirectiveDefinitionList) ForName(name string) *DirectiveDefinition {
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type DefinitionList []*Definition
+
+func (l DefinitionList) ForName(name string) *Definition {
+ for _, it := range l {
+ if it.Name == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type OperationTypeDefinitionList []*OperationTypeDefinition
+
+func (l OperationTypeDefinitionList) ForType(name string) *OperationTypeDefinition {
+ for _, it := range l {
+ if it.Type == name {
+ return it
+ }
+ }
+ return nil
+}
+
+type ChildValueList []*ChildValue
+
+func (v ChildValueList) ForName(name string) *Value {
+ for _, f := range v {
+ if f.Name == name {
+ return f.Value
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/definition.go b/vendor/github.com/vektah/gqlparser/v2/ast/definition.go
new file mode 100644
index 0000000000000..f5c8ea375374c
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/definition.go
@@ -0,0 +1,93 @@
+package ast
+
+type DefinitionKind string
+
+const (
+ Scalar DefinitionKind = "SCALAR"
+ Object DefinitionKind = "OBJECT"
+ Interface DefinitionKind = "INTERFACE"
+ Union DefinitionKind = "UNION"
+ Enum DefinitionKind = "ENUM"
+ InputObject DefinitionKind = "INPUT_OBJECT"
+)
+
+// ObjectDefinition is the core type definition object, it includes all of the definable types
+// but does *not* cover schema or directives.
+//
+// @vektah: Javascript implementation has different types for all of these, but they are
+// more similar than different and don't define any behaviour. I think this style of
+// "some hot" struct works better, at least for go.
+//
+// Type extensions are also represented by this same struct.
+type Definition struct {
+ Kind DefinitionKind
+ Description string
+ Name string
+ Directives DirectiveList
+ Interfaces []string // object and input object
+ Fields FieldList // object and input object
+ Types []string // union
+ EnumValues EnumValueList // enum
+
+ Position *Position `dump:"-"`
+ BuiltIn bool `dump:"-"`
+}
+
+func (d *Definition) IsLeafType() bool {
+ return d.Kind == Enum || d.Kind == Scalar
+}
+
+func (d *Definition) IsAbstractType() bool {
+ return d.Kind == Interface || d.Kind == Union
+}
+
+func (d *Definition) IsCompositeType() bool {
+ return d.Kind == Object || d.Kind == Interface || d.Kind == Union
+}
+
+func (d *Definition) IsInputType() bool {
+ return d.Kind == Scalar || d.Kind == Enum || d.Kind == InputObject
+}
+
+func (d *Definition) OneOf(types ...string) bool {
+ for _, t := range types {
+ if d.Name == t {
+ return true
+ }
+ }
+ return false
+}
+
+type FieldDefinition struct {
+ Description string
+ Name string
+ Arguments ArgumentDefinitionList // only for objects
+ DefaultValue *Value // only for input objects
+ Type *Type
+ Directives DirectiveList
+ Position *Position `dump:"-"`
+}
+
+type ArgumentDefinition struct {
+ Description string
+ Name string
+ DefaultValue *Value
+ Type *Type
+ Directives DirectiveList
+ Position *Position `dump:"-"`
+}
+
+type EnumValueDefinition struct {
+ Description string
+ Name string
+ Directives DirectiveList
+ Position *Position `dump:"-"`
+}
+
+type DirectiveDefinition struct {
+ Description string
+ Name string
+ Arguments ArgumentDefinitionList
+ Locations []DirectiveLocation
+ Position *Position `dump:"-"`
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/directive.go b/vendor/github.com/vektah/gqlparser/v2/ast/directive.go
new file mode 100644
index 0000000000000..9b07c92a0c0bd
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/directive.go
@@ -0,0 +1,42 @@
+package ast
+
+type DirectiveLocation string
+
+const (
+ // Executable
+ LocationQuery DirectiveLocation = `QUERY`
+ LocationMutation DirectiveLocation = `MUTATION`
+ LocationSubscription DirectiveLocation = `SUBSCRIPTION`
+ LocationField DirectiveLocation = `FIELD`
+ LocationFragmentDefinition DirectiveLocation = `FRAGMENT_DEFINITION`
+ LocationFragmentSpread DirectiveLocation = `FRAGMENT_SPREAD`
+ LocationInlineFragment DirectiveLocation = `INLINE_FRAGMENT`
+
+ // Type System
+ LocationSchema DirectiveLocation = `SCHEMA`
+ LocationScalar DirectiveLocation = `SCALAR`
+ LocationObject DirectiveLocation = `OBJECT`
+ LocationFieldDefinition DirectiveLocation = `FIELD_DEFINITION`
+ LocationArgumentDefinition DirectiveLocation = `ARGUMENT_DEFINITION`
+ LocationInterface DirectiveLocation = `INTERFACE`
+ LocationUnion DirectiveLocation = `UNION`
+ LocationEnum DirectiveLocation = `ENUM`
+ LocationEnumValue DirectiveLocation = `ENUM_VALUE`
+ LocationInputObject DirectiveLocation = `INPUT_OBJECT`
+ LocationInputFieldDefinition DirectiveLocation = `INPUT_FIELD_DEFINITION`
+)
+
+type Directive struct {
+ Name string
+ Arguments ArgumentList
+ Position *Position `dump:"-"`
+
+ // Requires validation
+ ParentDefinition *Definition
+ Definition *DirectiveDefinition
+ Location DirectiveLocation
+}
+
+func (d *Directive) ArgumentMap(vars map[string]interface{}) map[string]interface{} {
+ return arg2map(d.Definition.Arguments, d.Arguments, vars)
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/document.go b/vendor/github.com/vektah/gqlparser/v2/ast/document.go
new file mode 100644
index 0000000000000..4672d0c02ae50
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/document.go
@@ -0,0 +1,67 @@
+package ast
+
+type QueryDocument struct {
+ Operations OperationList
+ Fragments FragmentDefinitionList
+ Position *Position `dump:"-"`
+}
+
+type SchemaDocument struct {
+ Schema SchemaDefinitionList
+ SchemaExtension SchemaDefinitionList
+ Directives DirectiveDefinitionList
+ Definitions DefinitionList
+ Extensions DefinitionList
+ Position *Position `dump:"-"`
+}
+
+func (d *SchemaDocument) Merge(other *SchemaDocument) {
+ d.Schema = append(d.Schema, other.Schema...)
+ d.SchemaExtension = append(d.SchemaExtension, other.SchemaExtension...)
+ d.Directives = append(d.Directives, other.Directives...)
+ d.Definitions = append(d.Definitions, other.Definitions...)
+ d.Extensions = append(d.Extensions, other.Extensions...)
+}
+
+type Schema struct {
+ Query *Definition
+ Mutation *Definition
+ Subscription *Definition
+
+ Types map[string]*Definition
+ Directives map[string]*DirectiveDefinition
+
+ PossibleTypes map[string][]*Definition
+ Implements map[string][]*Definition
+}
+
+func (s *Schema) AddPossibleType(name string, def *Definition) {
+ s.PossibleTypes[name] = append(s.PossibleTypes[name], def)
+}
+
+// GetPossibleTypes will enumerate all the definitions for a given interface or union
+func (s *Schema) GetPossibleTypes(def *Definition) []*Definition {
+ return s.PossibleTypes[def.Name]
+}
+
+func (s *Schema) AddImplements(name string, iface *Definition) {
+ s.Implements[name] = append(s.Implements[name], iface)
+}
+
+// GetImplements returns all the interface and union definitions that the given definition satisfies
+func (s *Schema) GetImplements(def *Definition) []*Definition {
+ return s.Implements[def.Name]
+}
+
+type SchemaDefinition struct {
+ Description string
+ Directives DirectiveList
+ OperationTypes OperationTypeDefinitionList
+ Position *Position `dump:"-"`
+}
+
+type OperationTypeDefinition struct {
+ Operation Operation
+ Type string
+ Position *Position `dump:"-"`
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/dumper.go b/vendor/github.com/vektah/gqlparser/v2/ast/dumper.go
new file mode 100644
index 0000000000000..dbb7a7efaf381
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/dumper.go
@@ -0,0 +1,159 @@
+package ast
+
+import (
+ "bytes"
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+)
+
+// Dump turns ast into a stable string format for assertions in tests
+func Dump(i interface{}) string {
+ v := reflect.ValueOf(i)
+
+ d := dumper{Buffer: &bytes.Buffer{}}
+ d.dump(v)
+
+ return d.String()
+}
+
+type dumper struct {
+ *bytes.Buffer
+ indent int
+}
+
+type Dumpable interface {
+ Dump() string
+}
+
+func (d *dumper) dump(v reflect.Value) {
+ if dumpable, isDumpable := v.Interface().(Dumpable); isDumpable {
+ d.WriteString(dumpable.Dump())
+ return
+ }
+ switch v.Kind() {
+ case reflect.Bool:
+ if v.Bool() {
+ d.WriteString("true")
+ } else {
+ d.WriteString("false")
+ }
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ d.WriteString(fmt.Sprintf("%d", v.Int()))
+
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ d.WriteString(fmt.Sprintf("%d", v.Uint()))
+
+ case reflect.Float32, reflect.Float64:
+ d.WriteString(fmt.Sprintf("%.2f", v.Float()))
+
+ case reflect.String:
+ if v.Type().Name() != "string" {
+ d.WriteString(v.Type().Name() + "(" + strconv.Quote(v.String()) + ")")
+ } else {
+ d.WriteString(strconv.Quote(v.String()))
+ }
+
+ case reflect.Array, reflect.Slice:
+ d.dumpArray(v)
+
+ case reflect.Interface, reflect.Ptr:
+ d.dumpPtr(v)
+
+ case reflect.Struct:
+ d.dumpStruct(v)
+
+ default:
+ panic(fmt.Errorf("unsupported kind: %s\n buf: %s", v.Kind().String(), d.String()))
+ }
+}
+
+func (d *dumper) writeIndent() {
+ d.Buffer.WriteString(strings.Repeat(" ", d.indent))
+}
+
+func (d *dumper) nl() {
+ d.Buffer.WriteByte('\n')
+ d.writeIndent()
+}
+
+func typeName(t reflect.Type) string {
+ if t.Kind() == reflect.Ptr {
+ return typeName(t.Elem())
+ }
+ return t.Name()
+}
+
+func (d *dumper) dumpArray(v reflect.Value) {
+ d.WriteString("[" + typeName(v.Type().Elem()) + "]")
+
+ for i := 0; i < v.Len(); i++ {
+ d.nl()
+ d.WriteString("- ")
+ d.indent++
+ d.dump(v.Index(i))
+ d.indent--
+ }
+}
+
+func (d *dumper) dumpStruct(v reflect.Value) {
+ d.WriteString("<" + v.Type().Name() + ">")
+ d.indent++
+
+ typ := v.Type()
+ for i := 0; i < v.NumField(); i++ {
+ f := v.Field(i)
+ if typ.Field(i).Tag.Get("dump") == "-" {
+ continue
+ }
+
+ if isZero(f) {
+ continue
+ }
+ d.nl()
+ d.WriteString(typ.Field(i).Name)
+ d.WriteString(": ")
+ d.dump(v.Field(i))
+ }
+
+ d.indent--
+}
+
+func isZero(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.Ptr, reflect.Interface:
+ return v.IsNil()
+ case reflect.Func, reflect.Map:
+ return v.IsNil()
+
+ case reflect.Array, reflect.Slice:
+ if v.IsNil() {
+ return true
+ }
+ z := true
+ for i := 0; i < v.Len(); i++ {
+ z = z && isZero(v.Index(i))
+ }
+ return z
+ case reflect.Struct:
+ z := true
+ for i := 0; i < v.NumField(); i++ {
+ z = z && isZero(v.Field(i))
+ }
+ return z
+ case reflect.String:
+ return v.String() == ""
+ }
+
+ // Compare other types directly:
+ return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()))
+}
+
+func (d *dumper) dumpPtr(v reflect.Value) {
+ if v.IsNil() {
+ d.WriteString("nil")
+ return
+ }
+ d.dump(v.Elem())
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/fragment.go b/vendor/github.com/vektah/gqlparser/v2/ast/fragment.go
new file mode 100644
index 0000000000000..57ab56c7c68b2
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/fragment.go
@@ -0,0 +1,38 @@
+package ast
+
+type FragmentSpread struct {
+ Name string
+ Directives DirectiveList
+
+ // Require validation
+ ObjectDefinition *Definition
+ Definition *FragmentDefinition
+
+ Position *Position `dump:"-"`
+}
+
+type InlineFragment struct {
+ TypeCondition string
+ Directives DirectiveList
+ SelectionSet SelectionSet
+
+ // Require validation
+ ObjectDefinition *Definition
+
+ Position *Position `dump:"-"`
+}
+
+type FragmentDefinition struct {
+ Name string
+ // Note: fragment variable definitions are experimental and may be changed
+ // or removed in the future.
+ VariableDefinition VariableDefinitionList
+ TypeCondition string
+ Directives DirectiveList
+ SelectionSet SelectionSet
+
+ // Require validation
+ Definition *Definition
+
+ Position *Position `dump:"-"`
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/operation.go b/vendor/github.com/vektah/gqlparser/v2/ast/operation.go
new file mode 100644
index 0000000000000..03e916a088493
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/operation.go
@@ -0,0 +1,29 @@
+package ast
+
+type Operation string
+
+const (
+ Query Operation = "query"
+ Mutation Operation = "mutation"
+ Subscription Operation = "subscription"
+)
+
+type OperationDefinition struct {
+ Operation Operation
+ Name string
+ VariableDefinitions VariableDefinitionList
+ Directives DirectiveList
+ SelectionSet SelectionSet
+ Position *Position `dump:"-"`
+}
+
+type VariableDefinition struct {
+ Variable string
+ Type *Type
+ DefaultValue *Value
+ Position *Position `dump:"-"`
+
+ // Requires validation
+ Definition *Definition
+ Used bool `dump:"-"`
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/path.go b/vendor/github.com/vektah/gqlparser/v2/ast/path.go
new file mode 100644
index 0000000000000..9af1684388b46
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/path.go
@@ -0,0 +1,67 @@
+package ast
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+)
+
+var _ json.Unmarshaler = (*Path)(nil)
+
+type Path []PathElement
+
+type PathElement interface {
+ isPathElement()
+}
+
+var _ PathElement = PathIndex(0)
+var _ PathElement = PathName("")
+
+func (path Path) String() string {
+ var str bytes.Buffer
+ for i, v := range path {
+ switch v := v.(type) {
+ case PathIndex:
+ str.WriteString(fmt.Sprintf("[%d]", v))
+ case PathName:
+ if i != 0 {
+ str.WriteByte('.')
+ }
+ str.WriteString(string(v))
+ default:
+ panic(fmt.Sprintf("unknown type: %T", v))
+ }
+ }
+ return str.String()
+}
+
+func (path *Path) UnmarshalJSON(b []byte) error {
+ var vs []interface{}
+ err := json.Unmarshal(b, &vs)
+ if err != nil {
+ return err
+ }
+
+ *path = make([]PathElement, 0, len(vs))
+ for _, v := range vs {
+ switch v := v.(type) {
+ case string:
+ *path = append(*path, PathName(v))
+ case int:
+ *path = append(*path, PathIndex(v))
+ case float64:
+ *path = append(*path, PathIndex(int(v)))
+ default:
+ return fmt.Errorf("unknown path element type: %T", v)
+ }
+ }
+ return nil
+}
+
+type PathIndex int
+
+func (_ PathIndex) isPathElement() {}
+
+type PathName string
+
+func (_ PathName) isPathElement() {}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/selection.go b/vendor/github.com/vektah/gqlparser/v2/ast/selection.go
new file mode 100644
index 0000000000000..159db84471306
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/selection.go
@@ -0,0 +1,39 @@
+package ast
+
+type SelectionSet []Selection
+
+type Selection interface {
+ isSelection()
+ GetPosition() *Position
+}
+
+func (*Field) isSelection() {}
+func (*FragmentSpread) isSelection() {}
+func (*InlineFragment) isSelection() {}
+
+func (s *Field) GetPosition() *Position { return s.Position }
+func (s *FragmentSpread) GetPosition() *Position { return s.Position }
+func (s *InlineFragment) GetPosition() *Position { return s.Position }
+
+type Field struct {
+ Alias string
+ Name string
+ Arguments ArgumentList
+ Directives DirectiveList
+ SelectionSet SelectionSet
+ Position *Position `dump:"-"`
+
+ // Require validation
+ Definition *FieldDefinition
+ ObjectDefinition *Definition
+}
+
+type Argument struct {
+ Name string
+ Value *Value
+ Position *Position `dump:"-"`
+}
+
+func (f *Field) ArgumentMap(vars map[string]interface{}) map[string]interface{} {
+ return arg2map(f.Definition.Arguments, f.Arguments, vars)
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/source.go b/vendor/github.com/vektah/gqlparser/v2/ast/source.go
new file mode 100644
index 0000000000000..2949f83f7bba3
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/source.go
@@ -0,0 +1,19 @@
+package ast
+
+// Source covers a single *.graphql file
+type Source struct {
+ // Name is the filename of the source
+ Name string
+ // Input is the actual contents of the source file
+ Input string
+ // BuiltIn indicate whether the source is a part of the specification
+ BuiltIn bool
+}
+
+type Position struct {
+ Start int // The starting position, in runes, of this token in the input.
+ End int // The end position, in runes, of this token in the input.
+ Line int // The line number at the start of this item.
+ Column int // The column number at the start of this item.
+ Src *Source // The source document this token belongs to
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/type.go b/vendor/github.com/vektah/gqlparser/v2/ast/type.go
new file mode 100644
index 0000000000000..9577fdb48cbc7
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/type.go
@@ -0,0 +1,68 @@
+package ast
+
+func NonNullNamedType(named string, pos *Position) *Type {
+ return &Type{NamedType: named, NonNull: true, Position: pos}
+}
+
+func NamedType(named string, pos *Position) *Type {
+ return &Type{NamedType: named, NonNull: false, Position: pos}
+}
+
+func NonNullListType(elem *Type, pos *Position) *Type {
+ return &Type{Elem: elem, NonNull: true, Position: pos}
+}
+
+func ListType(elem *Type, pos *Position) *Type {
+ return &Type{Elem: elem, NonNull: false, Position: pos}
+}
+
+type Type struct {
+ NamedType string
+ Elem *Type
+ NonNull bool
+ Position *Position `dump:"-"`
+}
+
+func (t *Type) Name() string {
+ if t.NamedType != "" {
+ return t.NamedType
+ }
+
+ return t.Elem.Name()
+}
+
+func (t *Type) String() string {
+ nn := ""
+ if t.NonNull {
+ nn = "!"
+ }
+ if t.NamedType != "" {
+ return t.NamedType + nn
+ }
+
+ return "[" + t.Elem.String() + "]" + nn
+}
+
+func (t *Type) IsCompatible(other *Type) bool {
+ if t.NamedType != other.NamedType {
+ return false
+ }
+
+ if t.Elem != nil && other.Elem == nil {
+ return false
+ }
+
+ if t.Elem != nil && !t.Elem.IsCompatible(other.Elem) {
+ return false
+ }
+
+ if other.NonNull {
+ return t.NonNull
+ }
+
+ return true
+}
+
+func (v *Type) Dump() string {
+ return v.String()
+}
diff --git a/vendor/github.com/vektah/gqlparser/v2/ast/value.go b/vendor/github.com/vektah/gqlparser/v2/ast/value.go
new file mode 100644
index 0000000000000..c25ef15059359
--- /dev/null
+++ b/vendor/github.com/vektah/gqlparser/v2/ast/value.go
@@ -0,0 +1,120 @@
+package ast
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+type ValueKind int
+
+const (
+ Variable ValueKind = iota
+ IntValue
+ FloatValue
+ StringValue
+ BlockValue
+ BooleanValue
+ NullValue
+ EnumValue
+ ListValue
+ ObjectValue
+)
+
+type Value struct {
+ Raw string
+ Children ChildValueList
+ Kind ValueKind
+ Position *Position `dump:"-"`
+
+ // Require validation
+ Definition *Definition
+ VariableDefinition *VariableDefinition
+ ExpectedType *Type
+}
+
+type ChildValue struct {
+ Name string
+ Value *Value
+ Position *Position `dump:"-"`
+}
+
+func (v *Value) Value(vars map[string]interface{}) (interface{}, error) {
+ if v == nil {
+ return nil, nil
+ }
+ switch v.Kind {
+ case Variable:
+ if value, ok := vars[v.Raw]; ok {
+ return value, nil
+ }
+ if v.VariableDefinition != nil && v.VariableDefinition.DefaultValue != nil {
+ return v.VariableDefinition.DefaultValue.Value(vars)
+ }
+ return nil, nil
+ case IntValue:
+ return strconv.ParseInt(v.Raw, 10, 64)
+ case FloatValue:
+ return strconv.ParseFloat(v.Raw, 64)
+ case StringValue, BlockValue, EnumValue:
+ return v.Raw, nil
+ case BooleanValue:
+ return strconv.ParseBool(v.Raw)
+ case NullValue:
+ return nil, nil
+ case ListValue:
+ var val []interface{}
+ for _, elem := range v.Children {
+ elemVal, err := elem.Value.Value(vars)
+ if err != nil {
+ return val, err
+ }
+ val = append(val, elemVal)
+ }
+ return val, nil
+ case ObjectValue:
+ val := map[string]interface{}{}
+ for _, elem := range v.Children {
+ elemVal, err := elem.Value.Value(vars)
+ if err != nil {
+ return val, err
+ }
+ val[elem.Name] = elemVal
+ }
+ return val, nil
+ default:
+ panic(fmt.Errorf("unknown value kind %d", v.Kind))
+ }
+}
+
+func (v *Value) String() string {
+ if v == nil {
+ return "