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 କରାଇପାରେ। ଯଦି ସମଗ୍ର ୱାର୍କଫ୍ଲୋ ଗୋଟିଏ ପଥ ଆବଶ୍ୟକ କରେ, ତେବେ ଏହି ସେୟାର କରାଯାଇଥିବା ସିଲେକ୍ଟରକୁ ଅଧା ବାଟରେ ବଦଳାଇବା ପରିବର୍ତ୍ତେ ୱାର୍କଫ୍ଲୋ ସୀମାରେ ସେହି ପଥ ନ୍ୟସ୍ତ କରନ୍ତୁ।