func runPublisher(startwg, donewg *sync.WaitGroup, opts nats.Options, numMsgs int, msgSize int, async bool, pubID string, maxPubAcksInflight int, subj string, numSubs int) {
var snc stan.Conn
var err error
nc := getNextNatsConn()
if nc == nil {
snc, err = stan.Connect("test-cluster", pubID, stan.MaxPubAcksInflight(maxPubAcksInflight), stan.ConnectWait(DefaultConnectWait))
} else {
snc, err = stan.Connect("test-cluster", pubID,
stan.MaxPubAcksInflight(maxPubAcksInflight), stan.NatsConn(nc), stan.ConnectWait(DefaultConnectWait))
}
if err != nil {
log.Fatalf("Publisher %s can't connect: %v\n", pubID, err)
}
startwg.Done()
var msg []byte
if msgSize > 0 {
msg = make([]byte, msgSize)
}
start := time.Now()
if useUniqueSubjects {
publishMsgsOnUniqueSubjects(snc, msg, async, numMsgs, subj, numSubs)
} else {
publishMsgs(snc, msg, async, numMsgs, subj)
}
benchmark.AddPubSample(bench.NewSample(numMsgs, msgSize, start, time.Now(), snc.NatsConn()))
snc.Close()
donewg.Done()
}
func runSubscriber(startwg, donewg *sync.WaitGroup, opts nats.Options, numMsgs int, msgSize int, ignoreOld bool, subID string) {
snc, err := stan.Connect("test-cluster", subID)
if err != nil {
log.Fatalf("Subscriber %s can't connect: %v\n", subID, err)
}
args := flag.Args()
subj := args[0]
ch := make(chan bool)
start := time.Now()
received := 0
mcb := func(msg *stan.Msg) {
received++
if received >= numMsgs {
ch <- true
}
}
if ignoreOld {
snc.Subscribe(subj, mcb)
} else {
snc.Subscribe(subj, mcb, stan.DeliverAllAvailable())
}
startwg.Done()
<-ch
benchmark.AddSubSample(bench.NewSample(numMsgs, msgSize, start, time.Now(), snc.NatsConn()))
snc.Close()
donewg.Done()
}
func runPublisher(startwg, donewg *sync.WaitGroup, opts nats.Options, numMsgs int, msgSize int) {
nc, err := opts.Connect()
if err != nil {
log.Fatalf("Can't connect: %v\n", err)
}
defer nc.Close()
startwg.Done()
args := flag.Args()
subj := args[0]
var msg []byte
if msgSize > 0 {
msg = make([]byte, msgSize)
}
start := time.Now()
for i := 0; i < numMsgs; i++ {
nc.Publish(subj, msg)
}
nc.Flush()
benchmark.AddPubSample(bench.NewSample(numMsgs, msgSize, start, time.Now(), nc))
donewg.Done()
}
func runPublisher(startwg, donewg *sync.WaitGroup, opts nats.Options, numMsgs int, msgSize int, async bool, pubID string, maxPubAcksInflight int) {
snc, err := stan.Connect("test-cluster", pubID, stan.MaxPubAcksInflight(maxPubAcksInflight))
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) {
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()
donewg.Done()
}
func runSubscriber(startwg, donewg *sync.WaitGroup, opts nats.Options, numMsgs int, msgSize int, ignoreOld bool, subID, subj string) {
var snc stan.Conn
var err error
nc := getNextNatsConn()
if nc == nil {
snc, err = stan.Connect("test-cluster", subID, stan.ConnectWait(DefaultConnectWait))
} else {
snc, err = stan.Connect("test-cluster", subID, stan.NatsConn(nc), stan.ConnectWait(DefaultConnectWait))
}
if err != nil {
log.Fatalf("Subscriber %s can't connect: %v\n", subID, err)
}
time.Sleep(time.Duration(rand.Intn(10000)) * time.Millisecond)
ch := make(chan bool)
start := time.Now()
st.initSubscriber(subj)
received := 0
mcb := func(msg *stan.Msg) {
received++
if received >= numMsgs {
/*f verbose {
log.Printf("Done receiving on %s.\n", msg.Subject)
}*/
st.completeSubscriber(subj)
ch <- true
}
}
if ignoreOld {
snc.Subscribe(subj, mcb, stan.AckWait(time.Second*120))
} else {
snc.Subscribe(subj, mcb, stan.DeliverAllAvailable(), stan.AckWait(time.Second*120))
}
startwg.Done()
<-ch
benchmark.AddSubSample(bench.NewSample(numMsgs, msgSize, start, time.Now(), snc.NatsConn()))
snc.Close()
donewg.Done()
}
func runSubscriber(startwg, donewg *sync.WaitGroup, opts nats.Options, numMsgs int, msgSize int) {
nc, err := opts.Connect()
if err != nil {
log.Fatalf("Can't connect: %v\n", err)
}
args := flag.Args()
subj := args[0]
received := 0
start := time.Now()
nc.Subscribe(subj, func(msg *nats.Msg) {
received++
if received >= numMsgs {
benchmark.AddSubSample(bench.NewSample(numMsgs, msgSize, start, time.Now(), nc))
donewg.Done()
nc.Close()
}
})
nc.Flush()
startwg.Done()
}