Golang and Gin web framework - Execute code after router.Run()

I am fairly new to Go, so please excuse me if this is something obvious.

I am busy writing some code in Go for OAuth 2.0 Authentication. Part of this means that I need to have a callback URL available. In my code I need to create a callback endpoint, and once this is up and running I need to call an Authorization endpoint which will then reach out to my callback endpoint.

My problem being that calling Run() in Gin is blocking my execution, so I can't do any further authorization after my callback endpoint is up and running. Is there a way to maybe run this code in a separate GoRoutine so that I can finish my Authorization flow afterwards?

Here is a rough example of my code in my main function:

r := gin.Default()
//ReqHandler is an HtttpHandler func
r.GET("/redirect", ReqHandler)

r.Run(":5001")
ContinueAuth()

Create a listener in the main goroutine. Start the HTTP server in a goroutine. Continue with auth flow in the main goroutine.

r := gin.Default()
r.GET("/redirect", ReqHandler)

l, err := net.Listen("tcp", ":5001")
if err != nil {
    log.Fatal(err)
}

go func() {
   log.Fatal(r.RunListener(l))
}()

ContinueAuth()

select {} // wait forever

Creating the listener in the main goroutine ensures that the listener is ready for callbacks from the authentication flow.

> Note: this method will block the calling goroutine indefinitely unless an error happens.

The r.Run() will block the execution unless an error happens.

It is possible by running the Run() as go-routine and ContinueAuth() after it by.

package main

import (
	"fmt"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/redirect", ReqHandler)

	go func() {
		// serve and listen
		if err := r.Run(":8080"); err != nil {
			fmt.Println("Failed to start the server:", err)
			return
		}
	}()

	ContinueAuth()

	select {}
}

But ContinueAuth will run even when the Run raises an error too.

So we have to handle it differently, as the ContinueAuth() should only run after the server has successfully started.

• We will create a signal only channel, and start a go routine to listen the channel.
• When the signal received on the channel, we'll call ContinueAuth()
• We'll start another go-routine to send the signal into channel after 1 second. This is to wait for the server to run or fail.
• Start the server

Here is the implementation

package main

import (
	"fmt"
	"time"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/redirect", ReqHandler)

	done := make(chan struct{}, 1)

	// this go routine wait for getting a signal in done channel.
	// On channel close, then we know the server is running successfully
	// If it is not running successfully, then it means something went wrong with the listening
	{
		go func(done chan struct{}) {
			// Check the channel is closed
			if _, ok := <-done; !ok {
				fmt.Println("Channel is closed.. The server is running successfully")
				ContinueAuth()
			}
		}(done)
	}

	// send the channel close signal after 1 second....
	// as this will only run if the server started sucessfully,
	// else this code will not execute, the execution will fail at immediately
	//
	// We are assuming the server will fail within 1 second when something went wrong
	go func(done chan struct{}) {
		time.Sleep(time.Second) // updated
		close(done)
	}(done)

	// serve and listen
	if err := r.Run(":8080"); err != nil {
		fmt.Println("Failed to start the server:", err)
		return
	}

}

func ReqHandler(c *gin.Context) {
}

func ContinueAuth() {
	fmt.Println(".............. [ContinueAuth] ............... ")
}

Hope this helps

I have accepted the answer from @thwd but I figured I would add the workaround that I am currently using in case anyone is interested (or in case it's bad and someone would like to correct me!).

I used a wait group and started the gin server in a GoRoutine:

func main(){
 var wg sync.WaitGroup

 wg.Add(1)

 go ConfigureGin(&wg)
 
 ContinueAuth()
 wg.Wait()
}

func ConfigureGin(wg *sync.WaitGroup){
 r := gin.Default()
 r.Get("/redirect",ReqHandler)
 r.Run(":5001")
 wg.Done()
}