amdprophet · June 29, 2021 20:00 · Mar 16, 2016 · Mar 16, 2016 · Nov 10, 2014 · Nov 10, 2014
diff --git a/embedded.go b/embedded.go
@@ -3,10 +3,11 @@ package main
 // This is a basic example of running an nsqd instance embedded. It creates
 // and runs an nsqd with all of the default options, and then produces
 // and consumes a single message. You are probably better off running a
-// standalone instance, but embedding it can simpllify deployment.
+// standalone instance, but embedding it can simplify deployment and is
+// useful in testing.
 
-// See https://github.com/bitly/nsq/blob/master/nsqd/options.go and
-// https://github.com/bitly/nsq/blob/master/apps/nsqd/nsqd.go for
+// See https://github.com/nsqio/nsq/blob/master/nsqd/options.go and
+// https://github.com/nsqio/nsq/blob/master/apps/nsqd/nsqd.go for
 // more details on how to configure an embedded nsqd instance.
 import (
 	"bytes"
@@ -31,6 +32,8 @@ func main() {
 		opts := nsqd.NewOptions()
 		nsqd := nsqd.New(opts)
 		nsqd.Main()
+
+		// wait until we are told to continue and exit
 		<-done
 		nsqd.Exit()
 	}()

diff --git a/embedded.go b/embedded.go
@@ -13,8 +13,8 @@ import (
 	"log"
 	"time"
 
-	"github.com/bitly/go-nsq"
-	"github.com/bitly/nsq/nsqd"
+	"github.com/nsqio/go-nsq"
+	"github.com/nsqio/nsq/nsqd"
 )
 
 func main() {
@@ -28,8 +28,8 @@ func main() {
 		// binary mainly wraps up the handling of command
 		// line args and does something similar
 
-		opts := nsqd.NewNSQDOptions()
-		nsqd := nsqd.NewNSQD(opts)
+		opts := nsqd.NewOptions()
+		nsqd := nsqd.New(opts)
 		nsqd.Main()
 		<-done
 		nsqd.Exit()

diff --git a/embedded.go b/embedded.go
@@ -11,31 +11,29 @@ package main
 import (
 	"bytes"
 	"log"
-
 	"time"
 
 	"github.com/bitly/go-nsq"
 	"github.com/bitly/nsq/nsqd"
 )
 
-func runDefaultNSQD(done chan bool) {
-
-	// running an nsqd with all of the default options (as if you
-	// ran it from the command line with no flags) is literally
-	// these three lines of code. the nsqd binary mainly wraps up
-	// the handling of command line args and does something similar
-	opts := nsqd.NewNSQDOptions()
-	nsqd := nsqd.NewNSQD(opts)
-	nsqd.Main()
-	<-done
-	nsqd.Exit()
-}
-
 func main() {
 	done := make(chan bool)
 
 	// Run the embedded nsqd in a go routine
-	go runDefaultNSQD(done)
+	go func() {
+		// running an nsqd with all of the default options
+		// (as if you ran it from the command line with no flags)
+		// is literally these three lines of code. the nsqd
+		// binary mainly wraps up the handling of command
+		// line args and does something similar
+
+		opts := nsqd.NewNSQDOptions()
+		nsqd := nsqd.NewNSQD(opts)
+		nsqd.Main()
+		<-done
+		nsqd.Exit()
+	}()
 
 	cfg := nsq.NewConfig()
 

diff --git a/embedded.go b/embedded.go
@@ -2,37 +2,41 @@ package main
 
 // This is a basic example of running an nsqd instance embedded. It creates
 // and runs an nsqd with all of the default options, and then produces
-// and consumes a single message.
+// and consumes a single message. You are probably better off running a
+// standalone instance, but embedding it can simpllify deployment.
 
 // See https://github.com/bitly/nsq/blob/master/nsqd/options.go and
 // https://github.com/bitly/nsq/blob/master/apps/nsqd/nsqd.go for
 // more details on how to configure an embedded nsqd instance.
 import (
 	"bytes"
 	"log"
-	"os"
-	"os/signal"
-	"syscall"
+
 	"time"
 
 	"github.com/bitly/go-nsq"
 	"github.com/bitly/nsq/nsqd"
 )
 
-func runDefaultNSQD() {
+func runDefaultNSQD(done chan bool) {
 
-	signalChan := make(chan os.Signal, 1)
-	signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
+	// running an nsqd with all of the default options (as if you
+	// ran it from the command line with no flags) is literally
+	// these three lines of code. the nsqd binary mainly wraps up
+	// the handling of command line args and does something similar
 	opts := nsqd.NewNSQDOptions()
 	nsqd := nsqd.NewNSQD(opts)
 	nsqd.Main()
-	<-signalChan
+	<-done
 	nsqd.Exit()
 }
 
 func main() {
+	done := make(chan bool)
+
 	// Run the embedded nsqd in a go routine
-	go runDefaultNSQD()
+	go runDefaultNSQD(done)
+
 	cfg := nsq.NewConfig()
 
 	// the message we'll send to ourselves
@@ -43,8 +47,9 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
+
 	// Publish a single message to the 'embedded' topic
-	err = p.Publish("embedded", msg) //[]byte("one message"))
+	err = p.Publish("embedded", msg)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -54,21 +59,26 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
+
 	// and a single handler that just checks that the message we
 	// received matches the message we sent
 	c.AddHandler(nsq.HandlerFunc(func(m *nsq.Message) error {
-		if bytes.Compare(m.Body, msg) != 0 { //"one message" {
+		if bytes.Compare(m.Body, msg) != 0 {
 			log.Fatal("message didn't match:", string(m.Body))
 		} else {
 			log.Println("message matched:", string(m.Body))
 		}
 		return nil
 	}))
+
 	// Connect the consumer to the embedded nsqd instance
 	c.ConnectToNSQD("localhost:4150")
 
 	// Sleep a little to give everything time to start up and let
 	// our producer and consumer run
 	time.Sleep(250 * time.Millisecond)
 
+	// tell the nsqd instance to exit
+	done <- true
+
 }
diff --git a/embedded.go b/embedded.go
@@ -58,9 +58,9 @@ func main() {
 	// received matches the message we sent
 	c.AddHandler(nsq.HandlerFunc(func(m *nsq.Message) error {
 		if bytes.Compare(m.Body, msg) != 0 { //"one message" {
-			log.Fatal(m)
+			log.Fatal("message didn't match:", string(m.Body))
 		} else {
-			log.Println("sent and received:", string(m.Body))
+			log.Println("message matched:", string(m.Body))
 		}
 		return nil
 	}))

diff --git a/embedded.go b/embedded.go
@@ -21,8 +21,6 @@ import (
 
 func runDefaultNSQD() {
 
-	//rand.Seed(time.Now().UTC().UnixNano())
-
 	signalChan := make(chan os.Signal, 1)
 	signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
 	opts := nsqd.NewNSQDOptions()

diff --git a/embedded.go b/embedded.go
@@ -1,7 +1,76 @@
 package main
 
+// This is a basic example of running an nsqd instance embedded. It creates
+// and runs an nsqd with all of the default options, and then produces
+// and consumes a single message.
 
-func main() {
+// See https://github.com/bitly/nsq/blob/master/nsqd/options.go and
+// https://github.com/bitly/nsq/blob/master/apps/nsqd/nsqd.go for
+// more details on how to configure an embedded nsqd instance.
+import (
+	"bytes"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/bitly/go-nsq"
+	"github.com/bitly/nsq/nsqd"
+)
+
+func runDefaultNSQD() {
 
+	//rand.Seed(time.Now().UTC().UnixNano())
+
+	signalChan := make(chan os.Signal, 1)
+	signal.Notify(signalChan, syscall.SIGINT, syscall.SIGTERM)
+	opts := nsqd.NewNSQDOptions()
+	nsqd := nsqd.NewNSQD(opts)
+	nsqd.Main()
+	<-signalChan
+	nsqd.Exit()
 }
 
+func main() {
+	// Run the embedded nsqd in a go routine
+	go runDefaultNSQD()
+	cfg := nsq.NewConfig()
+
+	// the message we'll send to ourselves
+	msg := []byte("the message")
+
+	// Set up a Producer, pointing at the default host:port
+	p, err := nsq.NewProducer("localhost:4150", cfg)
+	if err != nil {
+		log.Fatal(err)
+	}
+	// Publish a single message to the 'embedded' topic
+	err = p.Publish("embedded", msg) //[]byte("one message"))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Now set up a consumer
+	c, err := nsq.NewConsumer("embedded", "local", cfg)
+	if err != nil {
+		log.Fatal(err)
+	}
+	// and a single handler that just checks that the message we
+	// received matches the message we sent
+	c.AddHandler(nsq.HandlerFunc(func(m *nsq.Message) error {
+		if bytes.Compare(m.Body, msg) != 0 { //"one message" {
+			log.Fatal(m)
+		} else {
+			log.Println("sent and received:", string(m.Body))
+		}
+		return nil
+	}))
+	// Connect the consumer to the embedded nsqd instance
+	c.ConnectToNSQD("localhost:4150")
+
+	// Sleep a little to give everything time to start up and let
+	// our producer and consumer run
+	time.Sleep(250 * time.Millisecond)
+
+}
diff --git a/embedded.go b/embedded.go
@@ -0,0 +1,7 @@
+package main
+
+
+func main() {
+
+}
+