main.go

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/openframebox/goqueue"
)

// TaskMessage represents a task to be processed
type TaskMessage struct {
	Name string `json:"name"`
	Data string `json:"data"`
}

func (t TaskMessage) QueueName() string {
	return "tasks"
}

// TaskHandler processes task messages
type TaskHandler struct{}

func (h *TaskHandler) QueueName() string {
	return "tasks"
}

func (h *TaskHandler) Handle(ctx context.Context, envelope *goqueue.Envelope) error {
	log.Printf("Processing task: %s (retry: %d)", envelope.ID, envelope.RetryCount)

	// Simulate work
	time.Sleep(100 * time.Millisecond)

	return nil
}

func main() {
	// Create RabbitMQ backend with all features enabled
	backend, err := goqueue.NewRabbitMQBackend(
		"", // empty URL - using component config instead
		goqueue.WithRabbitMQHost("localhost", 5672),
		goqueue.WithRabbitMQAuth("root", "@passWORD1"), // No encoding needed!
		goqueue.WithRabbitMQVHost("/"),
		goqueue.WithRabbitMQDurableQueues(true),
		goqueue.WithRabbitMQPersistence(true),
		goqueue.WithRabbitMQPrefetch(10, 0),
		goqueue.WithRabbitMQPriority(10),
		goqueue.WithRabbitMQDLX("goqueue.dlx", "dead-letter-queue"),
	)
	if err != nil {
		log.Fatalf("Failed to create RabbitMQ backend: %v", err)
	}
	defer backend.Close()

	// Create queue with DLQ enabled
	gq := goqueue.New(
		backend,
		goqueue.WithWorkerCount(5),
		goqueue.WithRetryCount(3),
		goqueue.WithRetryDelay(1*time.Second),
		goqueue.WithDLQ("dead-letter-queue"),
	)

	// Register handler
	if err := gq.Register(&TaskHandler{}); err != nil {
		log.Fatalf("Failed to register handler: %v", err)
	}

	// Start processing
	ctx := context.Background()
	if err := gq.Start(ctx); err != nil {
		log.Fatalf("Failed to start queue: %v", err)
	}

	// Publish some tasks
	for i := 0; i < 10; i++ {
		task := TaskMessage{
			Name: fmt.Sprintf("Task %d", i+1),
			Data: fmt.Sprintf("Data for task %d", i+1),
		}
		if err := gq.Publish(ctx, task); err != nil {
			log.Printf("Failed to publish task: %v", err)
		}
	}

	log.Println("Published 10 tasks")

	// Wait a bit for processing
	time.Sleep(5 * time.Second)

	// Graceful shutdown
	if err := gq.Stop(); err != nil {
		log.Printf("Error stopping queue: %v", err)
	}

	log.Println("Done!")
}