mirror of
https://github.com/openfaas/faas.git
synced 2025-06-22 23:03:24 +00:00
Allow dot in function name
This patch enables the use-case for multiple namepsaces by allowing a dot to be used in the function name. dep has been run to update OpenFaaS projects and also to prune unused files. Tested by doing a build. Signed-off-by: Alex Ellis (OpenFaaS Ltd) <alexellis2@gmail.com>
This commit is contained in:
Alex Ellis (OpenFaaS Ltd)
committed by
Alex Ellis
Alex Ellis
parent
dc3c5fb9b3
commit
0a90125aba
257
gateway/vendor/github.com/nats-io/go-nats-streaming/benchmark_test.go
generated
vendored
257
gateway/vendor/github.com/nats-io/go-nats-streaming/benchmark_test.go
generated
vendored
@ -1,257 +0,0 @@
|
||||
// Copyright 2016-2018 The NATS Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
package stan
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Benchmarks
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func BenchmarkPublish(b *testing.B) {
|
||||
b.StopTimer()
|
||||
|
||||
// Run a NATS Streaming server
|
||||
s := RunServer(clusterName)
|
||||
defer s.Shutdown()
|
||||
sc := NewDefaultConnection(b)
|
||||
defer sc.Close()
|
||||
|
||||
hw := []byte("Hello World")
|
||||
|
||||
b.StartTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
if err := sc.Publish("foo", hw); err != nil {
|
||||
b.Fatalf("Got error on publish: %v\n", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkPublishAsync(b *testing.B) {
|
||||
b.StopTimer()
|
||||
|
||||
// Run a NATS Streaming server
|
||||
s := RunServer(clusterName)
|
||||
defer s.Shutdown()
|
||||
sc := NewDefaultConnection(b)
|
||||
defer sc.Close()
|
||||
|
||||
hw := []byte("Hello World")
|
||||
|
||||
ch := make(chan bool)
|
||||
received := int32(0)
|
||||
|
||||
ah := func(guid string, err error) {
|
||||
if err != nil {
|
||||
b.Fatalf("Received an error in ack callback: %v\n", err)
|
||||
}
|
||||
if nr := atomic.AddInt32(&received, 1); nr >= int32(b.N) {
|
||||
ch <- true
|
||||
}
|
||||
}
|
||||
b.StartTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
if _, err := sc.PublishAsync("foo", hw, ah); err != nil {
|
||||
//fmt.Printf("Client status %v, Server status %v\n", s.nc.Status(), (sc.(*conn)).nc.Status())
|
||||
fmt.Printf("len(ackmap) = %d\n", len(sc.(*conn).pubAckMap))
|
||||
|
||||
b.Fatalf("Error from PublishAsync: %v\n", err)
|
||||
}
|
||||
}
|
||||
|
||||
err := WaitTime(ch, 10*time.Second)
|
||||
if err != nil {
|
||||
fmt.Printf("sc error is %v\n", sc.(*conn).nc.LastError())
|
||||
b.Fatal("Timed out waiting for ack messages")
|
||||
} else if atomic.LoadInt32(&received) != int32(b.N) {
|
||||
b.Fatalf("Received: %d", received)
|
||||
}
|
||||
|
||||
// msgs, bytes, _ := sc.(*conn).ackSubscription.MaxPending()
|
||||
// fmt.Printf("max pending msgs:%d bytes:%d\n", msgs, bytes)
|
||||
}
|
||||
|
||||
func BenchmarkSubscribe(b *testing.B) {
|
||||
b.StopTimer()
|
||||
|
||||
// Run a NATS Streaming server
|
||||
s := RunServer(clusterName)
|
||||
defer s.Shutdown()
|
||||
sc := NewDefaultConnection(b)
|
||||
defer sc.Close()
|
||||
|
||||
hw := []byte("Hello World")
|
||||
pch := make(chan bool)
|
||||
|
||||
// Queue up all the messages. Keep this outside of the timing.
|
||||
for i := 0; i < b.N; i++ {
|
||||
if i == b.N-1 {
|
||||
// last one
|
||||
sc.PublishAsync("foo", hw, func(lguid string, err error) {
|
||||
if err != nil {
|
||||
b.Fatalf("Got an error from ack handler, %v", err)
|
||||
}
|
||||
pch <- true
|
||||
})
|
||||
} else {
|
||||
sc.PublishAsync("foo", hw, nil)
|
||||
}
|
||||
}
|
||||
|
||||
// Wait for published to finish
|
||||
if err := WaitTime(pch, 10*time.Second); err != nil {
|
||||
b.Fatalf("Error waiting for publish to finish\n")
|
||||
}
|
||||
|
||||
ch := make(chan bool)
|
||||
received := int32(0)
|
||||
|
||||
b.StartTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
sc.Subscribe("foo", func(m *Msg) {
|
||||
if nr := atomic.AddInt32(&received, 1); nr >= int32(b.N) {
|
||||
ch <- true
|
||||
}
|
||||
}, DeliverAllAvailable())
|
||||
|
||||
err := WaitTime(ch, 10*time.Second)
|
||||
nr := atomic.LoadInt32(&received)
|
||||
if err != nil {
|
||||
b.Fatalf("Timed out waiting for messages, received only %d of %d\n", nr, b.N)
|
||||
} else if nr != int32(b.N) {
|
||||
b.Fatalf("Only Received: %d of %d", received, b.N)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkQueueSubscribe(b *testing.B) {
|
||||
b.StopTimer()
|
||||
|
||||
// Run a NATS Streaming server
|
||||
s := RunServer(clusterName)
|
||||
defer s.Shutdown()
|
||||
sc := NewDefaultConnection(b)
|
||||
defer sc.Close()
|
||||
|
||||
hw := []byte("Hello World")
|
||||
pch := make(chan bool)
|
||||
|
||||
// Queue up all the messages. Keep this outside of the timing.
|
||||
for i := 0; i < b.N; i++ {
|
||||
if i == b.N-1 {
|
||||
// last one
|
||||
sc.PublishAsync("foo", hw, func(lguid string, err error) {
|
||||
if err != nil {
|
||||
b.Fatalf("Got an error from ack handler, %v", err)
|
||||
}
|
||||
pch <- true
|
||||
})
|
||||
} else {
|
||||
sc.PublishAsync("foo", hw, nil)
|
||||
}
|
||||
}
|
||||
|
||||
// Wait for published to finish
|
||||
if err := WaitTime(pch, 10*time.Second); err != nil {
|
||||
b.Fatalf("Error waiting for publish to finish\n")
|
||||
}
|
||||
|
||||
ch := make(chan bool)
|
||||
received := int32(0)
|
||||
|
||||
b.StartTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
mcb := func(m *Msg) {
|
||||
if nr := atomic.AddInt32(&received, 1); nr >= int32(b.N) {
|
||||
ch <- true
|
||||
}
|
||||
}
|
||||
|
||||
sc.QueueSubscribe("foo", "bar", mcb, DeliverAllAvailable())
|
||||
sc.QueueSubscribe("foo", "bar", mcb, DeliverAllAvailable())
|
||||
sc.QueueSubscribe("foo", "bar", mcb, DeliverAllAvailable())
|
||||
sc.QueueSubscribe("foo", "bar", mcb, DeliverAllAvailable())
|
||||
|
||||
err := WaitTime(ch, 20*time.Second)
|
||||
nr := atomic.LoadInt32(&received)
|
||||
if err != nil {
|
||||
b.Fatalf("Timed out waiting for messages, received only %d of %d\n", nr, b.N)
|
||||
} else if nr != int32(b.N) {
|
||||
b.Fatalf("Only Received: %d of %d", received, b.N)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkPublishSubscribe(b *testing.B) {
|
||||
b.StopTimer()
|
||||
|
||||
// Run a NATS Streaming server
|
||||
s := RunServer(clusterName)
|
||||
defer s.Shutdown()
|
||||
sc := NewDefaultConnection(b)
|
||||
defer sc.Close()
|
||||
|
||||
hw := []byte("Hello World")
|
||||
|
||||
ch := make(chan bool)
|
||||
received := int32(0)
|
||||
|
||||
// Subscribe callback, counts msgs received.
|
||||
_, err := sc.Subscribe("foo", func(m *Msg) {
|
||||
if nr := atomic.AddInt32(&received, 1); nr >= int32(b.N) {
|
||||
ch <- true
|
||||
}
|
||||
}, DeliverAllAvailable())
|
||||
|
||||
if err != nil {
|
||||
b.Fatalf("Error subscribing, %v", err)
|
||||
}
|
||||
|
||||
b.StartTimer()
|
||||
b.ReportAllocs()
|
||||
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := sc.PublishAsync("foo", hw, func(guid string, err error) {
|
||||
if err != nil {
|
||||
b.Fatalf("Received an error in publish ack callback: %v\n", err)
|
||||
}
|
||||
})
|
||||
if err != nil {
|
||||
b.Fatalf("Error publishing %v\n", err)
|
||||
}
|
||||
}
|
||||
|
||||
err = WaitTime(ch, 30*time.Second)
|
||||
nr := atomic.LoadInt32(&received)
|
||||
if err != nil {
|
||||
b.Fatalf("Timed out waiting for messages, received only %d of %d\n", nr, b.N)
|
||||
} else if nr != int32(b.N) {
|
||||
b.Fatalf("Only Received: %d of %d", received, b.N)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkTimeNow(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
now := time.Now()
|
||||
now.Add(10 * time.Nanosecond)
|
||||
}
|
||||
}
|
||||
221
gateway/vendor/github.com/nats-io/go-nats-streaming/examples/stan-bench/main.go
generated
vendored
221
gateway/vendor/github.com/nats-io/go-nats-streaming/examples/stan-bench/main.go
generated
vendored
@ -1,221 +0,0 @@
|
||||
// Copyright 2016-2018 The NATS Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/nats-io/go-nats"
|
||||
"github.com/nats-io/go-nats-streaming"
|
||||
"github.com/nats-io/go-nats/bench"
|
||||
)
|
||||
|
||||
// Some sane defaults
|
||||
const (
|
||||
DefaultNumMsgs = 100000
|
||||
DefaultNumPubs = 1
|
||||
DefaultNumSubs = 0
|
||||
DefaultAsync = false
|
||||
DefaultMessageSize = 128
|
||||
DefaultIgnoreOld = false
|
||||
DefaultMaxPubAcksInflight = 1000
|
||||
DefaultClientID = "benchmark"
|
||||
)
|
||||
|
||||
func usage() {
|
||||
log.Fatalf("Usage: stan-bench [-s server (%s)] [--tls] [-id CLIENT_ID] [-np NUM_PUBLISHERS] [-ns NUM_SUBSCRIBERS] [-n NUM_MSGS] [-ms MESSAGE_SIZE] [-csv csvfile] [-mpa MAX_NUMBER_OF_PUBLISHED_ACKS_INFLIGHT] [-io] [-a] <subject>\n", nats.DefaultURL)
|
||||
}
|
||||
|
||||
var benchmark *bench.Benchmark
|
||||
|
||||
func main() {
|
||||
var clusterID string
|
||||
flag.StringVar(&clusterID, "c", "test-cluster", "The NATS Streaming cluster ID")
|
||||
flag.StringVar(&clusterID, "cluster", "test-cluster", "The NATS Streaming cluster ID")
|
||||
|
||||
var urls = flag.String("s", nats.DefaultURL, "The NATS server URLs (separated by comma")
|
||||
var tls = flag.Bool("tls", false, "Use TLS secure sonnection")
|
||||
var numPubs = flag.Int("np", DefaultNumPubs, "Number of concurrent publishers")
|
||||
var numSubs = flag.Int("ns", DefaultNumSubs, "Number of concurrent subscribers")
|
||||
var numMsgs = flag.Int("n", DefaultNumMsgs, "Number of messages to publish")
|
||||
var async = flag.Bool("a", DefaultAsync, "Async message publishing")
|
||||
var messageSize = flag.Int("ms", DefaultMessageSize, "Message size in bytes.")
|
||||
var ignoreOld = flag.Bool("io", DefaultIgnoreOld, "Subscribers ignore old messages")
|
||||
var maxPubAcks = flag.Int("mpa", DefaultMaxPubAcksInflight, "Max number of published acks in flight")
|
||||
var clientID = flag.String("id", DefaultClientID, "Benchmark process base client ID")
|
||||
var csvFile = flag.String("csv", "", "Save bench data to csv file")
|
||||
|
||||
log.SetFlags(0)
|
||||
flag.Usage = usage
|
||||
flag.Parse()
|
||||
|
||||
args := flag.Args()
|
||||
if len(args) != 1 {
|
||||
usage()
|
||||
}
|
||||
|
||||
// Setup the option block
|
||||
opts := nats.GetDefaultOptions()
|
||||
opts.Servers = strings.Split(*urls, ",")
|
||||
for i, s := range opts.Servers {
|
||||
opts.Servers[i] = strings.Trim(s, " ")
|
||||
}
|
||||
|
||||
opts.Secure = *tls
|
||||
|
||||
benchmark = bench.NewBenchmark("NATS Streaming", *numSubs, *numPubs)
|
||||
|
||||
var startwg sync.WaitGroup
|
||||
var donewg sync.WaitGroup
|
||||
|
||||
donewg.Add(*numPubs + *numSubs)
|
||||
|
||||
// Run Subscribers first
|
||||
startwg.Add(*numSubs)
|
||||
for i := 0; i < *numSubs; i++ {
|
||||
subID := fmt.Sprintf("%s-sub-%d", *clientID, i)
|
||||
go runSubscriber(&startwg, &donewg, opts, clusterID, *numMsgs, *messageSize, *ignoreOld, subID)
|
||||
}
|
||||
startwg.Wait()
|
||||
|
||||
// Now Publishers
|
||||
startwg.Add(*numPubs)
|
||||
pubCounts := bench.MsgsPerClient(*numMsgs, *numPubs)
|
||||
for i := 0; i < *numPubs; i++ {
|
||||
pubID := fmt.Sprintf("%s-pub-%d", *clientID, i)
|
||||
go runPublisher(&startwg, &donewg, opts, clusterID, pubCounts[i], *messageSize, *async, pubID, *maxPubAcks)
|
||||
}
|
||||
|
||||
log.Printf("Starting benchmark [msgs=%d, msgsize=%d, pubs=%d, subs=%d]\n", *numMsgs, *messageSize, *numPubs, *numSubs)
|
||||
|
||||
startwg.Wait()
|
||||
donewg.Wait()
|
||||
|
||||
benchmark.Close()
|
||||
fmt.Print(benchmark.Report())
|
||||
|
||||
if len(*csvFile) > 0 {
|
||||
csv := benchmark.CSV()
|
||||
ioutil.WriteFile(*csvFile, []byte(csv), 0644)
|
||||
fmt.Printf("Saved metric data in csv file %s\n", *csvFile)
|
||||
}
|
||||
}
|
||||
|
||||
func runPublisher(startwg, donewg *sync.WaitGroup, opts nats.Options, clusterID string, numMsgs int, msgSize int, async bool, pubID string, maxPubAcksInflight int) {
|
||||
nc, err := opts.Connect()
|
||||
if err != nil {
|
||||
log.Fatalf("Publisher %s can't connect: %v\n", pubID, err)
|
||||
}
|
||||
snc, err := stan.Connect(clusterID, pubID, stan.MaxPubAcksInflight(maxPubAcksInflight), stan.NatsConn(nc),
|
||||
stan.SetConnectionLostHandler(func(_ stan.Conn, reason error) {
|
||||
log.Fatalf("Connection lost, reason: %v", reason)
|
||||
}))
|
||||
if err != nil {
|
||||
log.Fatalf("Publisher %s can't connect: %v\n", pubID, err)
|
||||
}
|
||||
|
||||
startwg.Done()
|
||||
|
||||
args := flag.Args()
|
||||
|
||||
subj := args[0]
|
||||
var msg []byte
|
||||
if msgSize > 0 {
|
||||
msg = make([]byte, msgSize)
|
||||
}
|
||||
published := 0
|
||||
start := time.Now()
|
||||
|
||||
if async {
|
||||
ch := make(chan bool)
|
||||
acb := func(lguid string, err error) {
|
||||
if err != nil {
|
||||
log.Fatalf("Publisher %q got following error: %v", pubID, err)
|
||||
}
|
||||
published++
|
||||
if published >= numMsgs {
|
||||
ch <- true
|
||||
}
|
||||
}
|
||||
for i := 0; i < numMsgs; i++ {
|
||||
_, err := snc.PublishAsync(subj, msg, acb)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
<-ch
|
||||
} else {
|
||||
for i := 0; i < numMsgs; i++ {
|
||||
err := snc.Publish(subj, msg)
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
published++
|
||||
}
|
||||
}
|
||||
|
||||
benchmark.AddPubSample(bench.NewSample(numMsgs, msgSize, start, time.Now(), snc.NatsConn()))
|
||||
snc.Close()
|
||||
nc.Close()
|
||||
donewg.Done()
|
||||
}
|
||||
|
||||
func runSubscriber(startwg, donewg *sync.WaitGroup, opts nats.Options, clusterID string, numMsgs int, msgSize int, ignoreOld bool, subID string) {
|
||||
nc, err := opts.Connect()
|
||||
if err != nil {
|
||||
log.Fatalf("Subscriber %s can't connect: %v\n", subID, err)
|
||||
}
|
||||
snc, err := stan.Connect(clusterID, subID, stan.NatsConn(nc),
|
||||
stan.SetConnectionLostHandler(func(_ stan.Conn, reason error) {
|
||||
log.Fatalf("Connection lost, reason: %v", reason)
|
||||
}))
|
||||
if err != nil {
|
||||
log.Fatalf("Subscriber %s can't connect: %v\n", subID, err)
|
||||
}
|
||||
|
||||
args := flag.Args()
|
||||
subj := args[0]
|
||||
ch := make(chan time.Time, 2)
|
||||
|
||||
received := 0
|
||||
mcb := func(msg *stan.Msg) {
|
||||
received++
|
||||
if received == 1 {
|
||||
ch <- time.Now()
|
||||
}
|
||||
if received >= numMsgs {
|
||||
ch <- time.Now()
|
||||
}
|
||||
}
|
||||
|
||||
if ignoreOld {
|
||||
snc.Subscribe(subj, mcb)
|
||||
} else {
|
||||
snc.Subscribe(subj, mcb, stan.DeliverAllAvailable())
|
||||
}
|
||||
startwg.Done()
|
||||
|
||||
start := <-ch
|
||||
end := <-ch
|
||||
benchmark.AddSubSample(bench.NewSample(numMsgs, msgSize, start, end, snc.NatsConn()))
|
||||
snc.Close()
|
||||
nc.Close()
|
||||
donewg.Done()
|
||||
}
|
||||
118
gateway/vendor/github.com/nats-io/go-nats-streaming/examples/stan-pub/main.go
generated
vendored
118
gateway/vendor/github.com/nats-io/go-nats-streaming/examples/stan-pub/main.go
generated
vendored
@ -1,118 +0,0 @@
|
||||
// Copyright 2016-2018 The NATS Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/nats-io/go-nats-streaming"
|
||||
)
|
||||
|
||||
var usageStr = `
|
||||
Usage: stan-pub [options] <subject> <message>
|
||||
|
||||
Options:
|
||||
-s, --server <url> NATS Streaming server URL(s)
|
||||
-c, --cluster <cluster name> NATS Streaming cluster name
|
||||
-id,--clientid <client ID> NATS Streaming client ID
|
||||
-a, --async Asynchronous publish mode
|
||||
`
|
||||
|
||||
// NOTE: Use tls scheme for TLS, e.g. stan-pub -s tls://demo.nats.io:4443 foo hello
|
||||
func usage() {
|
||||
fmt.Printf("%s\n", usageStr)
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
func main() {
|
||||
var clusterID string
|
||||
var clientID string
|
||||
var async bool
|
||||
var URL string
|
||||
|
||||
flag.StringVar(&URL, "s", stan.DefaultNatsURL, "The nats server URLs (separated by comma)")
|
||||
flag.StringVar(&URL, "server", stan.DefaultNatsURL, "The nats server URLs (separated by comma)")
|
||||
flag.StringVar(&clusterID, "c", "test-cluster", "The NATS Streaming cluster ID")
|
||||
flag.StringVar(&clusterID, "cluster", "test-cluster", "The NATS Streaming cluster ID")
|
||||
flag.StringVar(&clientID, "id", "stan-pub", "The NATS Streaming client ID to connect with")
|
||||
flag.StringVar(&clientID, "clientid", "stan-pub", "The NATS Streaming client ID to connect with")
|
||||
flag.BoolVar(&async, "a", false, "Publish asynchronously")
|
||||
flag.BoolVar(&async, "async", false, "Publish asynchronously")
|
||||
|
||||
log.SetFlags(0)
|
||||
flag.Usage = usage
|
||||
flag.Parse()
|
||||
|
||||
args := flag.Args()
|
||||
|
||||
if len(args) < 1 {
|
||||
usage()
|
||||
}
|
||||
|
||||
sc, err := stan.Connect(clusterID, clientID, stan.NatsURL(URL))
|
||||
if err != nil {
|
||||
log.Fatalf("Can't connect: %v.\nMake sure a NATS Streaming Server is running at: %s", err, URL)
|
||||
}
|
||||
defer sc.Close()
|
||||
|
||||
subj, msg := args[0], []byte(args[1])
|
||||
|
||||
ch := make(chan bool)
|
||||
var glock sync.Mutex
|
||||
var guid string
|
||||
acb := func(lguid string, err error) {
|
||||
glock.Lock()
|
||||
log.Printf("Received ACK for guid %s\n", lguid)
|
||||
defer glock.Unlock()
|
||||
if err != nil {
|
||||
log.Fatalf("Error in server ack for guid %s: %v\n", lguid, err)
|
||||
}
|
||||
if lguid != guid {
|
||||
log.Fatalf("Expected a matching guid in ack callback, got %s vs %s\n", lguid, guid)
|
||||
}
|
||||
ch <- true
|
||||
}
|
||||
|
||||
if !async {
|
||||
err = sc.Publish(subj, msg)
|
||||
if err != nil {
|
||||
log.Fatalf("Error during publish: %v\n", err)
|
||||
}
|
||||
log.Printf("Published [%s] : '%s'\n", subj, msg)
|
||||
} else {
|
||||
glock.Lock()
|
||||
guid, err = sc.PublishAsync(subj, msg, acb)
|
||||
if err != nil {
|
||||
log.Fatalf("Error during async publish: %v\n", err)
|
||||
}
|
||||
glock.Unlock()
|
||||
if guid == "" {
|
||||
log.Fatal("Expected non-empty guid to be returned.")
|
||||
}
|
||||
log.Printf("Published [%s] : '%s' [guid: %s]\n", subj, msg, guid)
|
||||
|
||||
select {
|
||||
case <-ch:
|
||||
break
|
||||
case <-time.After(5 * time.Second):
|
||||
log.Fatal("timeout")
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
165
gateway/vendor/github.com/nats-io/go-nats-streaming/examples/stan-sub/main.go
generated
vendored
165
gateway/vendor/github.com/nats-io/go-nats-streaming/examples/stan-sub/main.go
generated
vendored
@ -1,165 +0,0 @@
|
||||
// Copyright 2016-2018 The NATS Authors
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"os/signal"
|
||||
"time"
|
||||
|
||||
"github.com/nats-io/go-nats-streaming"
|
||||
"github.com/nats-io/go-nats-streaming/pb"
|
||||
)
|
||||
|
||||
var usageStr = `
|
||||
Usage: stan-sub [options] <subject>
|
||||
|
||||
Options:
|
||||
-s, --server <url> NATS Streaming server URL(s)
|
||||
-c, --cluster <cluster name> NATS Streaming cluster name
|
||||
-id,--clientid <client ID> NATS Streaming client ID
|
||||
|
||||
Subscription Options:
|
||||
--qgroup <name> Queue group
|
||||
--seq <seqno> Start at seqno
|
||||
--all Deliver all available messages
|
||||
--last Deliver starting with last published message
|
||||
--since <duration> Deliver messages in last interval (e.g. 1s, 1hr)
|
||||
(for more information: https://golang.org/pkg/time/#ParseDuration)
|
||||
--durable <name> Durable subscriber name
|
||||
--unsubscribe Unsubscribe the durable on exit
|
||||
`
|
||||
|
||||
// NOTE: Use tls scheme for TLS, e.g. stan-sub -s tls://demo.nats.io:4443 foo
|
||||
func usage() {
|
||||
log.Fatalf(usageStr)
|
||||
}
|
||||
|
||||
func printMsg(m *stan.Msg, i int) {
|
||||
log.Printf("[#%d] Received on [%s]: '%s'\n", i, m.Subject, m)
|
||||
}
|
||||
|
||||
func main() {
|
||||
var clusterID string
|
||||
var clientID string
|
||||
var showTime bool
|
||||
var startSeq uint64
|
||||
var startDelta string
|
||||
var deliverAll bool
|
||||
var deliverLast bool
|
||||
var durable string
|
||||
var qgroup string
|
||||
var unsubscribe bool
|
||||
var URL string
|
||||
|
||||
// defaultID := fmt.Sprintf("client.%s", nuid.Next())
|
||||
|
||||
flag.StringVar(&URL, "s", stan.DefaultNatsURL, "The nats server URLs (separated by comma)")
|
||||
flag.StringVar(&URL, "server", stan.DefaultNatsURL, "The nats server URLs (separated by comma)")
|
||||
flag.StringVar(&clusterID, "c", "test-cluster", "The NATS Streaming cluster ID")
|
||||
flag.StringVar(&clusterID, "cluster", "test-cluster", "The NATS Streaming cluster ID")
|
||||
flag.StringVar(&clientID, "id", "", "The NATS Streaming client ID to connect with")
|
||||
flag.StringVar(&clientID, "clientid", "", "The NATS Streaming client ID to connect with")
|
||||
flag.BoolVar(&showTime, "t", false, "Display timestamps")
|
||||
// Subscription options
|
||||
flag.Uint64Var(&startSeq, "seq", 0, "Start at sequence no.")
|
||||
flag.BoolVar(&deliverAll, "all", false, "Deliver all")
|
||||
flag.BoolVar(&deliverLast, "last", false, "Start with last value")
|
||||
flag.StringVar(&startDelta, "since", "", "Deliver messages since specified time offset")
|
||||
flag.StringVar(&durable, "durable", "", "Durable subscriber name")
|
||||
flag.StringVar(&qgroup, "qgroup", "", "Queue group name")
|
||||
flag.BoolVar(&unsubscribe, "unsubscribe", false, "Unsubscribe the durable on exit")
|
||||
|
||||
log.SetFlags(0)
|
||||
flag.Usage = usage
|
||||
flag.Parse()
|
||||
|
||||
args := flag.Args()
|
||||
|
||||
if clientID == "" {
|
||||
log.Printf("Error: A unique client ID must be specified.")
|
||||
usage()
|
||||
}
|
||||
if len(args) < 1 {
|
||||
log.Printf("Error: A subject must be specified.")
|
||||
usage()
|
||||
}
|
||||
|
||||
sc, err := stan.Connect(clusterID, clientID, stan.NatsURL(URL),
|
||||
stan.SetConnectionLostHandler(func(_ stan.Conn, reason error) {
|
||||
log.Fatalf("Connection lost, reason: %v", reason)
|
||||
}))
|
||||
if err != nil {
|
||||
log.Fatalf("Can't connect: %v.\nMake sure a NATS Streaming Server is running at: %s", err, URL)
|
||||
}
|
||||
log.Printf("Connected to %s clusterID: [%s] clientID: [%s]\n", URL, clusterID, clientID)
|
||||
|
||||
subj, i := args[0], 0
|
||||
|
||||
mcb := func(msg *stan.Msg) {
|
||||
i++
|
||||
printMsg(msg, i)
|
||||
}
|
||||
|
||||
startOpt := stan.StartAt(pb.StartPosition_NewOnly)
|
||||
|
||||
if startSeq != 0 {
|
||||
startOpt = stan.StartAtSequence(startSeq)
|
||||
} else if deliverLast {
|
||||
startOpt = stan.StartWithLastReceived()
|
||||
} else if deliverAll {
|
||||
log.Print("subscribing with DeliverAllAvailable")
|
||||
startOpt = stan.DeliverAllAvailable()
|
||||
} else if startDelta != "" {
|
||||
ago, err := time.ParseDuration(startDelta)
|
||||
if err != nil {
|
||||
sc.Close()
|
||||
log.Fatal(err)
|
||||
}
|
||||
startOpt = stan.StartAtTimeDelta(ago)
|
||||
}
|
||||
|
||||
sub, err := sc.QueueSubscribe(subj, qgroup, mcb, startOpt, stan.DurableName(durable))
|
||||
if err != nil {
|
||||
sc.Close()
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
log.Printf("Listening on [%s], clientID=[%s], qgroup=[%s] durable=[%s]\n", subj, clientID, qgroup, durable)
|
||||
|
||||
if showTime {
|
||||
log.SetFlags(log.LstdFlags)
|
||||
}
|
||||
|
||||
// Wait for a SIGINT (perhaps triggered by user with CTRL-C)
|
||||
// Run cleanup when signal is received
|
||||
signalChan := make(chan os.Signal, 1)
|
||||
cleanupDone := make(chan bool)
|
||||
signal.Notify(signalChan, os.Interrupt)
|
||||
go func() {
|
||||
for range signalChan {
|
||||
fmt.Printf("\nReceived an interrupt, unsubscribing and closing connection...\n\n")
|
||||
// Do not unsubscribe a durable on exit, except if asked to.
|
||||
if durable == "" || unsubscribe {
|
||||
sub.Unsubscribe()
|
||||
}
|
||||
sc.Close()
|
||||
cleanupDone <- true
|
||||
}
|
||||
}()
|
||||
<-cleanupDone
|
||||
}
|
||||
16
gateway/vendor/github.com/nats-io/go-nats-streaming/scripts/cov.sh
generated
vendored
16
gateway/vendor/github.com/nats-io/go-nats-streaming/scripts/cov.sh
generated
vendored
@ -1,16 +0,0 @@
|
||||
#!/bin/bash -e
|
||||
# Run from directory above via ./scripts/cov.sh
|
||||
|
||||
rm -rf ./cov
|
||||
mkdir cov
|
||||
go test -v -covermode=atomic -coverprofile=./cov/stan.out
|
||||
gocovmerge ./cov/*.out > acc.out
|
||||
rm -rf ./cov
|
||||
|
||||
# If we have an arg, assume travis run and push to coveralls. Otherwise launch browser results
|
||||
if [[ -n $1 ]]; then
|
||||
$HOME/gopath/bin/goveralls -coverprofile=acc.out
|
||||
rm -rf ./acc.out
|
||||
else
|
||||
go tool cover -html=acc.out
|
||||
fi
|
||||
2491
gateway/vendor/github.com/nats-io/go-nats-streaming/stan_test.go
generated
vendored
2491
gateway/vendor/github.com/nats-io/go-nats-streaming/stan_test.go
generated
vendored
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user