github.com/angryronald/go-kit@v0.0.0-20240505173814-ff2bd9c79dbf/test/docker/kafka/kafka.sample.cp.go

package kafka

// uncomment to test this [Not Working]

// package main

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

// 	"github.com/IBM/sarama"
// 	"github.com/ory/dockertest/v3"
// 	"github.com/ory/dockertest/v3/docker"
// )

// func main() {
// 	// Create a new pool of Docker containers
// 	pool, err := dockertest.NewPool("")
// 	if err != nil {
// 		log.Fatalf("Could not connect to Docker: %s", err)
// 	}

// 	// Set up options for Kafka container
// 	options := &dockertest.RunOptions{
// 		Repository: "confluentinc/cp-kafka",
// 		Tag:        "6.2.1",
// 		PortBindings: map[docker.Port][]docker.PortBinding{
// 			"9092/tcp": {
// 				{HostIP: "", HostPort: "9092"},
// 			},
// 		},
// 		Env: []string{
// 			"KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://localhost:9092",
// 			"KAFKA_AUTO_CREATE_TOPICS_ENABLE=false",
// 			"KAFKA_DELETE_TOPIC_ENABLE=true",
// 		},
// 		ExposedPorts: []string{"9092/tcp"},
// 	}

// 	// Run Kafka container
// 	resource, err := pool.RunWithOptions(options)
// 	if err != nil {
// 		log.Fatalf("Could not start Kafka container: %s", err)
// 	}
// 	defer func() {
// 		// Clean up and remove the Kafka container when done
// 		if err := pool.Purge(resource); err != nil {
// 			log.Fatalf("Could not purge Kafka container: %s", err)
// 		}
// 	}()

// 	// Wait for Kafka to be ready with an extended timeout
// 	// maxWait := 120 * time.Second // Adjust the timeout as needed
// 	if err := pool.Retry(func() error {
// 		// Set up a Kafka producer and try to produce a message
// 		producer, err := sarama.NewAsyncProducer([]string{"localhost:9092"}, nil)
// 		if err != nil {
// 			log.Printf("Error creating Kafka producer: %v", err)
// 			return err
// 		}
// 		defer func() {
// 			// Close the producer when done
// 			if err := producer.Close(); err != nil {
// 				log.Printf("Error closing Kafka producer: %v", err)
// 			}
// 		}()

// 		// Produce a test message
// 		producer.Input() <- &sarama.ProducerMessage{Topic: "test", Value: sarama.StringEncoder("test-message")}

// 		// Check if the message was successfully produced
// 		select {
// 		case err := <-producer.Errors():
// 			log.Printf("Error producing message: %v", err)
// 			return err.Err
// 		case <-producer.Successes():
// 			log.Println("Kafka is ready.")
// 			return nil
// 		}
// 	}); err != nil {
// 		log.Fatalf("Could not connect to Kafka: %s", err)
// 	}

// 	// At this point, Kafka should be running and ready to use.

// 	// You can use the Sarama Kafka client to interact with Kafka.
// 	// For example, you can create a Kafka producer and consumer and perform operations:

// 	// Create a Kafka producer
// 	producer, err := sarama.NewAsyncProducer([]string{"localhost:9092"}, nil)
// 	if err != nil {
// 		log.Fatalf("Could not create Kafka producer: %s", err)
// 	}
// 	defer func() {
// 		// Close the producer when done
// 		if err := producer.Close(); err != nil {
// 			log.Printf("Error closing Kafka producer: %v", err)
// 		}
// 	}()

// 	// Create a Kafka consumer
// 	consumer, err := sarama.NewConsumer([]string{"localhost:9092"}, nil)
// 	if err != nil {
// 		log.Fatalf("Could not create Kafka consumer: %s", err)
// 	}
// 	defer func() {
// 		// Close the consumer when done
// 		if err := consumer.Close(); err != nil {
// 			log.Printf("Error closing Kafka consumer: %v", err)
// 		}
// 	}()

// 	// Subscribe to a Kafka topic and consume messages

// 	// Handle signals to gracefully shut down the program
// 	signals := make(chan os.Signal, 1)
// 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
// 	<-signals

// 	fmt.Println("Shutting down Kafka...")
// }