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-ஐ ஏற்படுத்தலாம். முழு பணிப்பாய்வுக்கும் ஒரு வழி தேவைப்பட்டால், இந்தப் பகிரப்பட்ட தேர்வியை இடையில் மாற்றுவதற்குப் பதிலாக பணிப்பாய்வின் எல்லையில் அந்த வழியை ஒதுக்குங்கள்.