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 ಉಂಟುಮಾಡಬಹುದು. ಇಡೀ ಕಾರ್ಯಹರಿವಿಗೆ ಒಂದೇ ಮಾರ್ಗ ಬೇಕಾದರೆ, ಈ ಹಂಚಿದ ಆಯ್ಕೆಗಾರನನ್ನು ಮಧ್ಯದಲ್ಲಿ ಬದಲಿಸುವ ಬದಲು ಕಾರ್ಯಹರಿವಿನ ಗಡಿಯಲ್ಲಿ ಆ ಮಾರ್ಗವನ್ನು ನಿಗದಿಪಡಿಸಿ.