Building a basic token manager

// TokenGeneratorFunc is a function type that takes no
// arguments and returns an interface{} value
// and an error value. This function type
// is used to generate tokens.
type TokenGeneratorFunc func() (interface{}, error)

// TokenManager is a struct that manages
// the generation and caching of tokens.
type TokenManager struct {
    // token is an atomic.Value that stores
    // the current token value.
    // It uses atomic operations to
    // ensure thread-safety when accessing
    // or modifying the token value concurrently.
    token atomic.Value

    // duration specifies
    // the time duration for which a token
    // is valid and should be
    // generated duration time.Duration
    duration time.Duration


    // generatorFunc is a function of
    // type TokenGeneratorFunc
    // that generates a new token
    // when called.
    generatorFunc TokenGeneratorFunc

    // name is a string that
    // identifies the
    // TokenManager instance.
    name string

    // hasGeneratedFirstToken is a bool that
    // indicates whether the first token
    // has been generated or not.
    // It is used to handle
    // the first token generation
    // differently, if required.
    hasGeneratedFirstToken bool

    // blockFirstTime is a channel that
    // can be used to block the first
    // token generation until a signal
    // is received on the channel.
    // This can be useful in scenarios
    // where the first token generation
    // needs to be delayed or
    // synchronized with other operations.
    blockFirstTime chan bool

}

func NewTokenManager(
    name string,
    duration *time.Duration,
    generatorFunc TokenGeneratorFunc) *TokenManager {
    tm := &TokenManager{
        duration: *duration,
        generatorFunc: generatorFunc,
        name: name,
        // making the channel size 2 so it
        // doesn't block the first write
        blockFirstTime: make(chan bool, 2),
        hasGeneratedFirstToken: false,
    }
    tm.token.Store("")
    return tm
}

func (t *TokenManager) GetToken() interface{} {
   // If the first token hasn't been generated yet
   if !t.hasGeneratedFirstToken {
       // Block until a value is received from
       // the blockFirstTime channel
       <-t.blockFirstTime
   }

   // Return the current token value stored
   // in the atomic.Value
   return t.token.Load()
}

func (tm *TokenManager) RunTokenGenerator() {
   // Create a new ticker that fires at
   // intervals specified by tm.duration
   ticker := time.NewTicker(tm.duration)
   // Ensure the ticker is stopped
   // when this function returns
   defer ticker.Stop()

   // Generate and update the initial token
   tm.UpdateToken()

   // This loop will run indefinitely
   for range ticker.C {
       // On each tick, generate and update the token
       tm.UpdateToken()
   }
}

func (tm *TokenManager) UpdateToken() {
   // Print a message indicating that a new
   // token is being generated
   fmt.Println("Generating new session token
   for connecting to " + tm.name)

   // Call the token generator function
   // to generate a new token
   response, err := tm.generatorFunc()
   if err != nil {
       // If there was an error generating
       // the token, print the error and return
       fmt.Println("Error updating token:", err)
       return
   }

   // Store the newly generated token
   //in the atomic.Value
   tm.token.Store(response)

   // If this is the first time a token is being generated
   if !tm.hasGeneratedFirstToken {
       // Set the hasGeneratedFirstToken flag to true
       tm.hasGeneratedFirstToken = true

       // Send a value to the blockFirstTime channel
       // to unblock any goroutines waiting for
       // the first token generation
       tm.blockFirstTime <- true
   }

   // Print a message indicating that the
   // new token was successfully generated
   fmt.Println("Successfully generated new
    token for " + tm.name)
}