Update/delete vendor files

Refreshed / updated vendor dependencies

Tested with "make".

Signed-off-by: Alex Ellis (OpenFaaS Ltd) <alexellis2@gmail.com>

gateway/vendor/github.com/nats-io/go-nats/.travis.yml

@@ -1,21 +1,21 @@
 language: go
 sudo: false
 go:
+- 1.11.x
 - 1.10.x
-- 1.9.x
-- 1.8.x
+go_import_path: github.com/nats-io/go-nats
 install:
 - go get -t ./...
 - go get github.com/nats-io/gnatsd
 - go get github.com/mattn/goveralls
 - go get github.com/wadey/gocovmerge
-- go get -u honnef.co/go/tools/cmd/megacheck
+- go get -u honnef.co/go/tools/cmd/staticcheck
 - go get -u github.com/client9/misspell/cmd/misspell
 before_script:
 - $(exit $(go fmt ./... | wc -l))
 - go vet ./...
 - misspell -error -locale US .
-- megacheck -ignore "$(cat staticcheck.ignore)" ./...
+- staticcheck -ignore "$(cat staticcheck.ignore)" ./...
 script:
-- go test -i -race ./... 
-- if [[ "$TRAVIS_GO_VERSION" == 1.9.* ]]; then ./scripts/cov.sh TRAVIS; else go test -v -race ./...; fi
+- go test -i -race ./...
+- if [[ "$TRAVIS_GO_VERSION" =~ 1.11 ]]; then ./scripts/cov.sh TRAVIS; else go test -race ./...; fi

gateway/vendor/github.com/nats-io/go-nats/GOVERNANCE.md

@@ -0,0 +1,3 @@
+# NATS Go Client Governance
+
+NATS Go Client (go-nats) is part of the NATS project and is subject to the [NATS Governance](https://github.com/nats-io/nats-general/blob/master/GOVERNANCE.md).

gateway/vendor/github.com/nats-io/go-nats/MAINTAINERS.md

@@ -0,0 +1,10 @@
+# Maintainers
+
+Maintainership is on a per project basis.
+
+### Core-maintainers
+  - Derek Collison <derek@nats.io> [@derekcollison](https://github.com/derekcollison)
+  - Ivan Kozlovic <ivan@nats.io> [@kozlovic](https://github.com/kozlovic)
+  
+### Maintainers
+  - Waldemar Quevedo <wally@nats.io> [@wallyqs](https://github.com/wallyqs)

gateway/vendor/github.com/nats-io/go-nats/OWNERS

@@ -1,7 +0,0 @@
-reviewers:
-  - derekcollison
-  - kozlovic
-  - wallyqs
-approvers:
-  - derekcollison
-  - kozlovic

gateway/vendor/github.com/nats-io/go-nats/README.md

@@ -2,6 +2,7 @@
 A [Go](http://golang.org) client for the [NATS messaging system](https://nats.io).
 
 [![License Apache 2](https://img.shields.io/badge/License-Apache2-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fnats-io%2Fgo-nats.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fnats-io%2Fgo-nats?ref=badge_shield)
 [![Go Report Card](https://goreportcard.com/badge/github.com/nats-io/go-nats)](https://goreportcard.com/report/github.com/nats-io/go-nats) [![Build Status](https://travis-ci.org/nats-io/go-nats.svg?branch=master)](http://travis-ci.org/nats-io/go-nats) [![GoDoc](https://godoc.org/github.com/nats-io/go-nats?status.svg)](http://godoc.org/github.com/nats-io/go-nats) [![Coverage Status](https://coveralls.io/repos/nats-io/go-nats/badge.svg?branch=master)](https://coveralls.io/r/nats-io/go-nats?branch=master)
 
 ## Installation
@@ -17,7 +18,9 @@ go get github.com/nats-io/gnatsd
 ## Basic Usage
 
 ```go
+import nats "github.com/nats-io/go-nats"
 
+// Connect to a server
 nc, _ := nats.Connect(nats.DefaultURL)
 
 // Simple Publisher
@@ -40,6 +43,9 @@ msg := <- ch
 // Unsubscribe
 sub.Unsubscribe()
 
+// Drain
+sub.Drain()
+
 // Requests
 msg, err := nc.Request("help", []byte("help me"), 10*time.Millisecond)
 
@@ -48,9 +54,12 @@ nc.Subscribe("help", func(m *Msg) {
     nc.Publish(m.Reply, []byte("I can help!"))
 })
 
+// Drain connection (Preferred for responders)
+// Close() not needed if this is called.
+nc.Drain()
+
 // Close connection
-nc, _ := nats.Connect("nats://localhost:4222")
-nc.Close();
+nc.Close()
 ```
 
 ## Encoded Connections
@@ -107,6 +116,48 @@ c.Subscribe("help", func(subj, reply string, msg string) {
 c.Close();
 ```
 
+## New Authentication (Nkeys and User Credentials)
+This requires server with version >= 2.0.0
+
+NATS servers have a new security and authentication mechanism to authenticate with user credentials and Nkeys.
+The simplest form is to use the helper method UserCredentials(credsFilepath).
+```go
+nc, err := nats.Connect(url, UserCredentials("user.creds"))
+```
+
+The helper methos creates two callback handlers to present the user JWT and sign the nonce challenge from the server.
+The core client library never has direct access to your private key and simply performs the callback for signing the server challenge.
+The helper will load and wipe and erase memory it uses for each connect or reconnect.
+
+The helper also can take two entries, one for the JWT and one for the NKey seed file.
+```go
+nc, err := nats.Connect(url, UserCredentials("user.jwt", "user.nk"))
+```
+
+You can also set the callback handlers directly and manage challenge signing directly.
+```go
+nc, err := nats.Connect(url, UserJWT(jwtCB, sigCB))
+```
+
+Bare Nkeys are also supported. The nkey seed should be in a read only file, e.g. seed.txt
+```bash
+> cat seed.txt
+# This is my seed nkey!
+SUAGMJH5XLGZKQQWAWKRZJIGMOU4HPFUYLXJMXOO5NLFEO2OOQJ5LPRDPM
+```
+
+This is a helper function which will load and decode and do the proper signing for the server nonce.
+It will clear memory in between invocations.
+You can choose to use the low level option and provide the public key and a signature callback on your own.
+
+```go
+opt, err := nats.NkeyOptionFromSeed("seed.txt")
+nc, err := nats.Connect(serverUrl, opt)
+
+// Direct
+nc, err := nats.Connect(serverUrl, Nkey(pubNkey, sigCB))
+```
+
 ## TLS
 
 ```go
@@ -263,7 +314,7 @@ nc, err = nats.Connect(servers,
 	nats.DisconnectHandler(func(nc *nats.Conn) {
 		fmt.Printf("Got disconnected!\n")
 	}),
-	nats.ReconnectHandler(func(_ *nats.Conn) {
+	nats.ReconnectHandler(func(nc *nats.Conn) {
 		fmt.Printf("Got reconnected to %v!\n", nc.ConnectedUrl())
 	}),
 	nats.ClosedHandler(func(nc *nats.Conn) {
@@ -329,3 +380,5 @@ err := c.RequestWithContext(ctx, "foo", req, resp)
 
 Unless otherwise noted, the NATS source files are distributed
 under the Apache Version 2.0 license found in the LICENSE file.
+
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fnats-io%2Fgo-nats.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fnats-io%2Fgo-nats?ref=badge_large)

gateway/vendor/github.com/nats-io/go-nats/context.go

@@ -18,7 +18,6 @@ package nats
 
 import (
 	"context"
-	"fmt"
 	"reflect"
 )
 
@@ -31,6 +30,11 @@ func (nc *Conn) RequestWithContext(ctx context.Context, subj string, data []byte
 	if nc == nil {
 		return nil, ErrInvalidConnection
 	}
+	// Check whether the context is done already before making
+	// the request.
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	}
 
 	nc.mu.Lock()
 	// If user wants the old style.
@@ -41,9 +45,7 @@ func (nc *Conn) RequestWithContext(ctx context.Context, subj string, data []byte
 
 	// Do setup for the new style.
 	if nc.respMap == nil {
-		// _INBOX wildcard
-		nc.respSub = fmt.Sprintf("%s.*", NewInbox())
-		nc.respMap = make(map[string]chan *Msg)
+		nc.initNewResp()
 	}
 	// Create literal Inbox and map to a chan msg.
 	mch := make(chan *Msg, RequestChanLen)
@@ -116,6 +118,9 @@ func (s *Subscription) NextMsgWithContext(ctx context.Context) (*Msg, error) {
 	if s == nil {
 		return nil, ErrBadSubscription
 	}
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	}
 
 	s.mu.Lock()
 	err := s.validateNextMsgState()
@@ -131,13 +136,26 @@ func (s *Subscription) NextMsgWithContext(ctx context.Context) (*Msg, error) {
 	var ok bool
 	var msg *Msg
 
+	// If something is available right away, let's optimize that case.
 	select {
 	case msg, ok = <-mch:
 		if !ok {
 			return nil, ErrConnectionClosed
 		}
-		err := s.processNextMsgDelivered(msg)
-		if err != nil {
+		if err := s.processNextMsgDelivered(msg); err != nil {
+			return nil, err
+		} else {
+			return msg, nil
+		}
+	default:
+	}
+
+	select {
+	case msg, ok = <-mch:
+		if !ok {
+			return nil, ErrConnectionClosed
+		}
+		if err := s.processNextMsgDelivered(msg); err != nil {
 			return nil, err
 		}
 	case <-ctx.Done():
@@ -147,6 +165,52 @@ func (s *Subscription) NextMsgWithContext(ctx context.Context) (*Msg, error) {
 	return msg, nil
 }
 
+// FlushWithContext will allow a context to control the duration
+// of a Flush() call. This context should be non-nil and should
+// have a deadline set. We will return an error if none is present.
+func (nc *Conn) FlushWithContext(ctx context.Context) error {
+	if nc == nil {
+		return ErrInvalidConnection
+	}
+	if ctx == nil {
+		return ErrInvalidContext
+	}
+	_, ok := ctx.Deadline()
+	if !ok {
+		return ErrNoDeadlineContext
+	}
+
+	nc.mu.Lock()
+	if nc.isClosed() {
+		nc.mu.Unlock()
+		return ErrConnectionClosed
+	}
+	// Create a buffered channel to prevent chan send to block
+	// in processPong()
+	ch := make(chan struct{}, 1)
+	nc.sendPing(ch)
+	nc.mu.Unlock()
+
+	var err error
+
+	select {
+	case _, ok := <-ch:
+		if !ok {
+			err = ErrConnectionClosed
+		} else {
+			close(ch)
+		}
+	case <-ctx.Done():
+		err = ctx.Err()
+	}
+
+	if err != nil {
+		nc.removeFlushEntry(ch)
+	}
+
+	return err
+}
+
 // RequestWithContext will create an Inbox and perform a Request
 // using the provided cancellation context with the Inbox reply
 // for the data v. A response will be decoded into the vPtrResponse.

gateway/vendor/github.com/nats-io/go-nats/enc.go

@@ -21,7 +21,7 @@ import (
 	"time"
 
 	// Default Encoders
-	. "github.com/nats-io/go-nats/encoders/builtin"
+	"github.com/nats-io/go-nats/encoders/builtin"
 )
 
 // Encoder interface is for all register encoders
@@ -43,9 +43,9 @@ const (
 func init() {
 	encMap = make(map[string]Encoder)
 	// Register json, gob and default encoder
-	RegisterEncoder(JSON_ENCODER, &JsonEncoder{})
-	RegisterEncoder(GOB_ENCODER, &GobEncoder{})
-	RegisterEncoder(DEFAULT_ENCODER, &DefaultEncoder{})
+	RegisterEncoder(JSON_ENCODER, &builtin.JsonEncoder{})
+	RegisterEncoder(GOB_ENCODER, &builtin.GobEncoder{})
+	RegisterEncoder(DEFAULT_ENCODER, &builtin.DefaultEncoder{})
 }
 
 // EncodedConn are the preferred way to interface with NATS. They wrap a bare connection to
@@ -67,7 +67,7 @@ func NewEncodedConn(c *Conn, encType string) (*EncodedConn, error) {
 	}
 	ec := &EncodedConn{Conn: c, Enc: EncoderForType(encType)}
 	if ec.Enc == nil {
-		return nil, fmt.Errorf("No encoder registered for '%s'", encType)
+		return nil, fmt.Errorf("no encoder registered for '%s'", encType)
 	}
 	return ec, nil
 }
@@ -207,9 +207,9 @@ func (c *EncodedConn) subscribe(subject, queue string, cb Handler) (*Subscriptio
 			}
 			if err := c.Enc.Decode(m.Subject, m.Data, oPtr.Interface()); err != nil {
 				if c.Conn.Opts.AsyncErrorCB != nil {
-					c.Conn.ach <- func() {
+					c.Conn.ach.push(func() {
 						c.Conn.Opts.AsyncErrorCB(c.Conn, m.Sub, errors.New("nats: Got an error trying to unmarshal: "+err.Error()))
-					}
+					})
 				}
 				return
 			}
@@ -254,6 +254,15 @@ func (c *EncodedConn) Close() {
 	c.Conn.Close()
 }
 
+// Drain will put a connection into a drain state. All subscriptions will
+// immediately be put into a drain state. Upon completion, the publishers
+// will be drained and can not publish any additional messages. Upon draining
+// of the publishers, the connection will be closed. Use the ClosedCB()
+// option to know when the connection has moved from draining to closed.
+func (c *EncodedConn) Drain() error {
+	return c.Conn.Drain()
+}
+
 // LastError reports the last error encountered via the Connection.
 func (c *EncodedConn) LastError() error {
 	return c.Conn.err

gateway/vendor/github.com/nats-io/go-nats/netchan.go

@@ -52,7 +52,7 @@ func chPublish(c *EncodedConn, chVal reflect.Value, subject string) {
 				if c.Conn.isClosed() {
 					go c.Conn.Opts.AsyncErrorCB(c.Conn, nil, e)
 				} else {
-					c.Conn.ach <- func() { c.Conn.Opts.AsyncErrorCB(c.Conn, nil, e) }
+					c.Conn.ach.push(func() { c.Conn.Opts.AsyncErrorCB(c.Conn, nil, e) })
 				}
 			}
 			return
@@ -88,7 +88,7 @@ func (c *EncodedConn) bindRecvChan(subject, queue string, channel interface{}) (
 		if err := c.Enc.Decode(m.Subject, m.Data, oPtr.Interface()); err != nil {
 			c.Conn.err = errors.New("nats: Got an error trying to unmarshal: " + err.Error())
 			if c.Conn.Opts.AsyncErrorCB != nil {
-				c.Conn.ach <- func() { c.Conn.Opts.AsyncErrorCB(c.Conn, m.Sub, c.Conn.err) }
+				c.Conn.ach.push(func() { c.Conn.Opts.AsyncErrorCB(c.Conn, m.Sub, c.Conn.err) })
 			}
 			return
 		}