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 ഉണ്ടാക്കാം. മുഴുവൻ വർക്ക്ഫ്ലോയ്ക്കും ഒരു റൂട്ട് ആവശ്യമെങ്കിൽ, ഈ പങ്കിട്ട സെലക്ടർ പകുതിയിൽ മാറ്റുന്നതിനുപകരം വർക്ക്ഫ്ലോ അതിർത്തിയിൽ ആ റൂട്ട് നൽകുക.