subscribe and waitGroup question

[tapan-thapa]

Hello Team,

I am beginner in GOLANG and NATS hence help required.

Producer code with Cobra and GIN (Working Fine):

// kanneldlrproducerCmd represents the kanneldlrproducer command
var kanneldlrproducerCmd = &cobra.Command{
	Use:   "kanneldlrproducer",
	Short: "Kannel DLR Producer",
	Long:  `This microservice accept delivery report from kannel and insert into NAT queue`,
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {

		queueName := args[0]

		err := godotenv.Load()
		if err != nil {
			log.Fatal("Error loading .env file")
		}

		log.Println("Kannel DLR producer started with queuename: " + queueName)

		// Connect to a server
		nc, _ := nats.Connect(os.Getenv("NATS_URL"), nats.RetryOnFailedConnect(true), nats.MaxReconnects(-1), nats.ReconnectWait(time.Second))
		c, _ := nats.NewEncodedConn(nc, nats.JSON_ENCODER)
		defer c.Close()

		gin.SetMode(os.Getenv("GIN_MODE"))
		r := gin.Default()
		r.GET("/api/dlr", func(gc *gin.Context) {

			//init the loc
			loc, _ := time.LoadLocation("Asia/Kolkata")

			const (
				dateFormat = "2006-01-02 15:04:05"
			)

			requestTime := time.Now().In(loc).Format(dateFormat)

			incomingDLR := &dlr{
				ID:                   gc.Query("id"),
				Status:               gc.Query("status"),
				Dlr:                  gc.Query("dlr"),
				Sender:               gc.Query("sender"),
				StatusMsg:            gc.Query("statusmsg"),
				SmsType:              gc.Query("type"),
				IncomingReceivedDate: gc.Query("receiveddate"),
				DeliveryType:         "KANNEL",
				To:                   gc.Query("to"),
				ReceivedDate:         requestTime,
				Smsc:                 gc.Query("smsc"),
				CutStatus:            gc.Query("cus_status"),
				CutDlrPer:            gc.Query("cus_dlr_per"),
				Uid:                  gc.Query("uid"),
				RegDel:               gc.Query("reg_del"),
				SmscID:               gc.Query("smsc_id"),
			}

			// Simple Publisher
			c.Publish(queueName, incomingDLR)

			gc.JSON(http.StatusOK, gin.H{
				"message": "Ok",
			})

		})

		r.Run(os.Getenv("KANNEL_DLR_LISTEN"))
	},
}

Consumer code with Cobra and GIN (Working Fine)

// kanneldlrconsumerCmd represents the kanneldlrconsumer command
var kanneldlrconsumerCmd = &cobra.Command{
	Use:   "kanneldlrconsumer",
	Short: "Kannel DLR Consumer",
	Long:  `This microservice takes delivery report from NAT server and insert into Redis List`,
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {

		queueName := args[0]

		err := godotenv.Load()
		if err != nil {
			log.Fatal("Error loading .env file")
		}

		log.Println("Kannel DLR consumer started with queuename: " + queueName)

		// Use a WaitGroup to wait for a message to arrive
		wg := sync.WaitGroup{}
		wg.Add(1)

		// Connect to a server
		nc, _ := nats.Connect(os.Getenv("NATS_URL"), nats.RetryOnFailedConnect(true), nats.MaxReconnects(-1), nats.ReconnectWait(time.Second))
		c, _ := nats.NewEncodedConn(nc, nats.JSON_ENCODER)
		defer c.Close()

		// Subscribe
		if _, err := c.Subscribe(queueName, func(d *dlr) {
			log.Printf("Received a dlr: %+v\n", d)
			defer wg.Done()
			wg.Add(1)
		}); err != nil {
			log.Fatal(err)
		}

		// Wait for a message to come in
		wg.Wait()

	},
}

My query/question is, in my consumer code without using waitGroup, my code was exiting just after subscribe and would like to know if waitGroup is the correct and right way so that subscribe code is not exit and keep getting data as and when sent by publisher/NATS?

[tpihl]

@tapan-thapa, I can see that you're new to go.

The question have nothing to do with nats. You will see it closing just as fast with all nats-calls removed, so this is the wrong place for a discussion about it.

The actual answer;
You are only starting things in different go-routines (the web-server and nats and so on). So nothing stops your program to exit.
Waitgroup will only help you if you decide what should trigger your shutdown. Looking at your code I would google on signal.NotifyContext as a way to wait for ctrl-c. That can be combined with waitgroups if you need to ensure a clean shutdown