go retry example

func rabbitConnect() (*amqp.Connection, error) {
	rabbitUser := os.Getenv("RABBIT_USER")
	rabbitPassword := os.Getenv("RABBIT_PASSWORD")
	rabbitHost := os.Getenv("RABBIT_HOST")
	rabbitVHost := os.Getenv("RABBIT_VHOST")
	rabbitPort := os.Getenv("RABBIT_PORT")
	conn, err := amqp.Dial(fmt.Sprintf("amqp://%s:%s@%s:%s/%s", rabbitUser, rabbitPassword, rabbitHost, rabbitPort, rabbitVHost))
	return conn, err
}

func rabbitRetry(attempts int, sleep time.Duration) *amqp.Connection {
	for i := 0; i < attempts; i++ {
		if conn, err := rabbitConnect(); err == nil {
			return conn
		}
		fmt.Println("Rabbit connection failed, retrying...")
		fmt.Println("Attempt: ", i)
		fmt.Println("Sleep: ", sleep)
		time.Sleep(sleep)
		sleep *= 2
	}
	return nil
}

func main() {
	conn := rabbitRetry(10, 5*time.Second)
	defer func(conn *amqp.Connection) {
		err := conn.Close()
		failOnError(err, "Failed to close a connection")
	}(conn)
  ch, err := conn.Channel()
}package main

import (
	"fmt"
	"io"
	"log"
	"math"
	"net/http"
	"sync"
	"time"
)

func main() {
	var (
		baseInterval       int           = 2
		baseIntervalTarget int           = 100 // 10800
		retryRequestTarget int           = 300
		tick               *time.Ticker  = time.NewTicker(time.Second * time.Duration(baseInterval))
		store              []interface{} = []interface{}{}
		interval           int           = 0
		increment          int           = 0
		retryRequest       int           = 0
		release            chan bool     = make(chan bool, 1)
		untilRelease       chan bool     = make(chan bool, 1)
		untilInterval      int           = 60 // 86400
	)

	for range tick.C {
		startTime := time.Now().Second()

		fmt.Printf("\n")
		fmt.Println("TIME NOW IN SECOND: ", startTime)

		n := int(math.Floor(float64((baseInterval + startTime) / 10)))
		interval += int(n)

		store = append(store, interval)
		increment++

		distinct := Distinct(store)

		fmt.Printf("\n")
		fmt.Println("SEQUENCES DATA: ", distinct)
		fmt.Println("INCREMENT DATA: ", increment)
		fmt.Printf("\n")

		position := IndexOf(increment, distinct)

		if position != -1 {
			retryRequest++
			HttpRequest(release)

			fmt.Println("SEQUENCES DATA MATCH: ", true)
			fmt.Println("RETRY REQUEST: ", retryRequest)
		} else {
			fmt.Println("SEQUENCES DATA NOT MATCH: ", false)
			fmt.Println("NO RETRY REQUEST: ", 0)
		}

		sumInterval := math.Ceil(float64(Reduce(SliceInterfaceToSliceInt(distinct)) / 10))
		fmt.Printf("\n")
		log.Println("INTERVAL: ", sumInterval)

		if c := int64(sumInterval); c >= int64(baseIntervalTarget) {
			fmt.Printf("\n")
			fmt.Println("STOP BY INTERVAL: ", c)

			interval = 0
			increment = 0
			retryRequest = 0
			store = nil

			time.AfterFunc(time.Duration(time.Second*time.Duration(untilInterval)), func() {
				untilRelease <- true
			})

			<-untilRelease

		} else if c := retryRequest; c >= retryRequestTarget {
			fmt.Printf("\n")
			fmt.Println("STOP BY RETRY REQUEST: ", c)

			interval = 0
			increment = 0
			retryRequest = 0
			store = nil

			time.AfterFunc(time.Duration(time.Second*time.Duration(untilInterval)), func() {
				untilRelease <- true
			})

			<-untilRelease
		}
	}
}

func HttpRequest(release chan bool) bool {
	res, err := http.Get("https://jsonplaceholder.typicode.com/users")

	if err != nil {
		release <- true
		log.Fatal(err.Error())
	}

	defer res.Body.Close()
	bodyByte, err := io.ReadAll(res.Body)

	if err != nil {
		release <- true
		log.Fatal(err.Error())
	}

	if len(bodyByte) > 0 {
		release <- true
	}

	<-release
	return true
}

func IndexOf(element interface{}, data []interface{}) interface{} {
	for k, v := range data {
		if element == v {
			return k
		}
	}
	return -1
}

func Distinct(data []interface{}) []interface{} {
	uniqueNumbers := make(map[interface{}]bool)
	result := []interface{}{}

	for _, num := range data {
		if !uniqueNumbers[num] {
			uniqueNumbers[num] = true
			result = append(result, num)
		}
	}

	return result
}

func Reduce(data []int) int64 {
	var sum int64

	for i := 0; i < len(data); i++ {
		sum += int64(data[i])
	}

	return sum
}

func SliceInterfaceToSliceInt(data []interface{}) []int {
	numbers := []int{}
	mutex := &sync.RWMutex{}

	for _, n := range data {
		mutex.Lock()
		numbers = append(numbers, n.(int))
		mutex.Unlock()
	}

	return numbers
}