curl https://get.docker.com | bash

services:
    nats:
        image: nats
        container_name: nats-server
        command: ["--http_port", "8222"]
        networks:
            - nats-net
        ports:
            - 4222:4222
            - 8222:8222

networks:
    nats-net:
        external: false
        name: nats-net

package main

import (
    "fmt"
	"os"
	"os/signal"
	"syscall"
    "log"
    "time"

    "github.com/nats-io/nats.go"
)

func main() {
    // Create a channel to listen for OS signals
	closeChan := make(chan os.Signal, 1)

	// Notify the channel when SIGINT (Ctrl+C) or SIGTERM is received
	signal.Notify(closeChan, os.Interrupt, syscall.SIGTERM)

	// Create a ticker that ticks every 5 seconds
	ticker := time.NewTicker(5 * time.Second)
	defer ticker.Stop()

    // Connect to NATS server
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatalf("Error connecting to NATS server: %v", err)
    }
    defer nc.Close()

	fmt.Println("Press Ctrl+C to exit...")

    // Publish messages every 5 seconds until terminate signal
    for {
        select {
            case <-ticker.C:
                // Publish messages every 5 seconds
                msg := fmt.Sprintf("Publishing %d", i)
                err := nc.Publish("messages", []byte(msg))
                if err != nil {
                    log.Fatalf("Error publishing message: %v", err)
                }
                fmt.Printf("Published: %s\n", msg)
            case sig := <-closeChan:
                // This block executes when a termination signal is received
                fmt.Printf("Received signal: %s. Exiting...\n", sig)
                return // Exit the loop and terminate the program
		}
    }
}

package main

import (
    "fmt"
	"os"
	"os/signal"
	"syscall"
    "log"

    "github.com/nats-io/nats.go"
)

func main() {
    // Create a channel to listen for OS signals
	closeChan := make(chan os.Signal, 1)

	// Notify the channel when SIGINT (Ctrl+C) or SIGTERM is received
	signal.Notify(closeChan, os.Interrupt, syscall.SIGTERM)

    // Connect to NATS server
    nc, err := nats.Connect(nats.DefaultURL)
    if err != nil {
        log.Fatalf("Error connecting to NATS server: %v", err)
    }
    defer nc.Close()

    // Subscribe to the "messages" subject
    _, err = nc.Subscribe("messages", func(msg *nats.Msg) {
        fmt.Printf("Received message: %s\n", string(msg.Data))
    })
    if err != nil {
        log.Fatalf("Error subscribing to subject: %v", err)
    }

    // This block executes when a termination signal is received
    sig := <-closeChan:
    fmt.Printf("Received signal: %s. Exiting...\n", sig)
    return // Exit the loop and terminate the program
}

docker compose up -d

go run publisher.go

go run subscriber.go