How to prioritize goroutines-CodePudding

I want to call two endpoints at the same time (A and B). But if I got a response 200 from both I need to use the response from A otherwise use B response. If B returns first I need to wait for A, in other words, I must use A whenever A returns 200.

Can you guys help me with the pattern?

Thank you

CodePudding user response：

Wait for a result from A. If the result is not good, then wait from a result from B. Use a buffered channel for the B result so that the sender does not block when A is good.

In the following snippet, fnA() and fnB() functions that issue requests to the endpoints.

a := make(chan *http.Response)
go func() {
    a <- fnA()

b := make(chan *http.Reasponse, 1) // Size > 0 is important!
go func() {
    b <- fnB()
}()

resp := <-a
if resp.StatusCode != 200 {
    resp = <-b
}

If the application does not execute code concurrently with A and B, then there's no need to use a goroutine for A:

b := make(chan *http.Response, 1) // Size > 0 is important!
go func() {
    b <- fnB()
}()

resp := fnA()
if resp.StatusCode != 200 {
    resp = <-b
}

CodePudding user response：

I'm suggesting you to use something like this, this is a bulky solution, but there you can start more than two endpoints for you needs.

func endpointPriorityTest() {

const (
    sourceA = "a"
    sourceB = "b"
    sourceC = "c"
)

type endpointResponse struct {
    source   string
    response *http.Response
    error
}

epResponseChan := make(chan *endpointResponse)

endpointsMap := map[string]string{
    sourceA: "https://jsonplaceholder.typicode.com/posts/1",
    sourceB: "https://jsonplaceholder.typicode.com/posts/10",
    sourceC: "https://jsonplaceholder.typicode.com/posts/100",
}

for source, endpointURL := range endpointsMap {
    source := source
    endpointURL := endpointURL
    go func(respChan chan<- *endpointResponse) {
        // You can add a delay so that the response from A takes longer than from B
        // and look to the result map
        // if source == sourceA {
        //  time.Sleep(time.Second)
        // }
        resp, err := http.Get(endpointURL)

        respChan <- &endpointResponse{
            source:   source,
            response: resp,
            error:    err,
        }
    }(epResponseChan)
}

respCache := make(map[string]*http.Response)

// Reading endpointURL responses from chan
for epResp := range epResponseChan {
    // Skips failed requests
    if epResp.error != nil {
        continue
    }

    // Save successful response to cache map
    respCache[epResp.source] = epResp.response

    // Interrupt reading channel if we've got an response from source A
    if epResp.source == sourceA {
        break
    }
}

fmt.Println("result map: ", respCache)

// Now we can use data from cache map
// resp, ok :=respCache[sourceA]
// if ok{
//  ...
// }
}

CodePudding user response：

Normally in golang, channel are used for communicating between goroutines. You can orchestrate your scenario with following sample code. basically you pass channel into your callB which will hold response. You don't need to run callB in goroutine as you always need result from that endpoint/service

package main

import (
    "fmt"
    "time"
)

func main() {
    resB := make(chan int)
    go callB(resB)
    res := callA()
    if res == 200 {
        fmt.Print("No Need for B")
    } else {
        res = <-resB
        fmt.Printf("Response from B : %d", res)
    }
}

func callA() int {
    time.Sleep(1000)
    return 200
}

func callB(res chan int) {
    time.Sleep(500)
    res <- 200
}