Client.Transport ਬਦਲੇ ਬਿਨਾਂ Go HTTP ਪ੍ਰੌਕਸੀ ਰੂਟ ਬਦਲੋ

ਜੇ http.Client ਪਹਿਲਾਂ ਹੀ ਸਮਕਾਲੀ ਬੇਨਤੀਆਂ ਦੁਆਰਾ ਸਾਂਝਾ ਹੈ, ਤਾਂ ਇਸ ਦਾ Transport ਫੀਲਡ ਸਥਿਰ ਰੱਖੋ। ਰੈਪਰ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਹਰ ਅਗਲੀ ਰਾਊਂਡ ਟ੍ਰਿਪ ਨੂੰ ਕਿਹੜਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਨਫ਼ਿਗਰ ਟ੍ਰਾਂਸਪੋਰਟ ਮਿਲੇਗਾ:

type routeSlot struct {
    mu sync.RWMutex
    current http.RoundTripper
}

func (s *routeSlot) RoundTrip(r *http.Request) (*http.Response, error) {
    s.mu.RLock()
    current := s.current
    s.mu.RUnlock()
    return current.RoundTrip(r)
}

func (s *routeSlot) Set(next http.RoundTripper) {
    s.mu.Lock()
    s.current = next
    s.mu.Unlock()
}

net/http ਅਤੇ sync ਵਰਤ ਕੇ ਕਲਾਇੰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਸ ਨੂੰ ਸ਼ੁਰੂ ਕਰੋ:

slot := &routeSlot{current: initialTransport}
client := &http.Client{Transport: slot}

slot.Set(nextTransport)

initialTransport ਅਤੇ nextTransport non-nil, ਪੂਰੀ ਤਰ੍ਹਾਂ ਕਨਫ਼ਿਗਰ ਅਤੇ ਸਮਕਾਲਤਾ ਲਈ ਸੁਰੱਖਿਅਤ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। ਹਰ ਪ੍ਰੌਕਸੀ ਟ੍ਰਾਂਸਪੋਰਟ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਬਣਾਓ, ਅਤੇ ਬੇਨਤੀਆਂ ਦੇ ਵਰਤੋਂ ਕਰਦਿਆਂ ਇਸ ਦੀ ਕਨਫ਼ਿਗਰੇਸ਼ਨ ਨਾ ਬਦਲੋ।

ਲਾਕ ਸਿਰਫ਼ ਪੌਇੰਟਰ ਸਨੈਪਸ਼ਾਟ ਦੀ ਰੱਖਿਆ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਹੌਲੀ ਬੇਨਤੀ ਆਪਣੇ ਪੂਰੇ ਨੈੱਟਵਰਕ ਬਦਲਾਅ ਦੌਰਾਨ ਰਾਊਟਿੰਗ ਲਾਕ ਨਹੀਂ ਫੜਦੀ। ਪਿਛਲਾ ਸਨੈਪਸ਼ਾਟ ਵਰਤਣ ਵਾਲੀ ਬੇਨਤੀ ਉਸੇ ਟ੍ਰਾਂਸਪੋਰਟ 'ਤੇ ਜਾਰੀ ਰਹਿੰਦੀ ਹੈ; ਬਦਲਾਅ ਇਸ ਨੂੰ ਦੁਬਾਰਾ ਨਹੀਂ ਚਲਾਉਂਦਾ ਅਤੇ ਨਾ ਹੀ ਇਸ ਦਾ ਕਨੈਕਸ਼ਨ ਹਿਲਾਉਂਦਾ ਹੈ।

ਪੁਰਾਣੇ ਟ੍ਰਾਂਸਪੋਰਟ ਐਪਲੀਕੇਸ਼ਨ ਦੇ ਸੀਮਤ ਜੀਵਨ ਚੱਕਰ ਦੌਰਾਨ ਰੱਖੋ ਅਤੇ ਰਿਟਾਇਰ ਕਰੋ, ਚੱਲ ਰਹੇ ਕੰਮ ਨੂੰ ਪੂਰਾ ਹੋਣ ਦਿਓ ਅਤੇ ਲੋੜ ਪੈਣ 'ਤੇ ਨਿਸ਼ਕਿਰਿਆ ਪੂਲ ਬੰਦ ਕਰੋ। ਰੀਡਾਇਰੈਕਟ ਬਦਲਾਅ ਤੋਂ ਬਾਅਦ ਇੱਕ ਹੋਰ RoundTrip ਕਰ ਸਕਦਾ ਹੈ। ਜੇ ਪੂਰੇ ਵਰਕਫ਼ਲੋ ਨੂੰ ਇੱਕ ਰੂਟ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਇਸ ਸਾਂਝੇ ਸਿਲੈਕਟਰ ਨੂੰ ਵਿਚਕਾਰ ਬਦਲਣ ਦੀ ਥਾਂ ਵਰਕਫ਼ਲੋ ਦੀ ਸੀਮਾ 'ਤੇ ਉਹ ਰੂਟ ਨਿਰਧਾਰਿਤ ਕਰੋ।