Node.js CONNECT ഹാൻഡ്ലർമാർ head ബഫർ സംരക്ഷിക്കണം
HTTP-യിൽ നിന്ന് ടണലിലേക്കുള്ള അതിർത്തിയിൽ Node-ന്റെ CONNECT സോക്കറ്റും head ബഫറും കൈകാര്യം ചെയ്യുക, ഹെഡറുകൾക്കപ്പുറം ഇതിനകം വായിച്ച ബൈറ്റുകൾ സംരക്ഷിച്ച്.
Node HTTP സെർവർ സാധാരണ പ്രോക്സി അഭ്യർത്ഥന അതിന്റെ request callback വഴി കൈകാര്യം ചെയ്യുന്നു. CONNECT മറ്റൊരു വഴി സ്വീകരിക്കുന്നു: സെർവർ അഭ്യർത്ഥന, ക്ലയന്റ് സോക്കറ്റ്, head ബഫർ എന്നിവയോടൊപ്പം connect പുറപ്പെടുവിക്കുന്നു.
ആ സംഭവം HTTP പാഴ്സിംഗും ടണലും തമ്മിലുള്ള കൈമാറ്റമാണ്. ടണൽ ചെയ്ത ട്രാഫിക്കിന് തുടർന്നും ഉപയോഗിക്കാൻ സാധാരണ ServerResponse ഒബ്ജക്റ്റ് ഇല്ല.
| ആർഗ്യുമെന്റ് | അത് എന്ത് വഹിക്കുന്നു |
|---|---|
req | CONNECT അഭ്യർത്ഥന, അതിന്റെ ലക്ഷ്യ അധികാരവും ഹെഡറുകളും ഉൾപ്പെടെ |
clientSocket | ക്ലയന്റിലേക്കുള്ള തിരിച്ചുള്ള കണക്ഷൻ |
head | Node ഇതിനകം HTTP ഹെഡറുകൾക്കപ്പുറം വായിച്ച ടണൽ ഡാറ്റ, ഒരുപക്ഷേ ശൂന്യം |
ബൈറ്റുകൾ റിലേ ചെയ്യുന്നതിന് മുമ്പ് HTTP തീരുമാനം പൂർത്തിയാക്കുക
അഭ്യർത്ഥിച്ച ഹോസ്റ്റും പോർട്ടും സാധൂകരിക്കുക, പ്രോക്സിയുടെ ആക്സസ്, പ്രാമാണീകരണ നയം പ്രയോഗിക്കുക, അപ്സ്ട്രീം കണക്ഷൻ സ്ഥാപിക്കുക. CONNECT service.example:443 പോലുള്ള ഒരു അധികാരം തിരിച്ചറിയുന്നു; ഓരോ കോളനിലും കണ്ണടച്ച് വിഭജിക്കുന്നതിന് പകരം IPv6 അധികാരങ്ങൾ മനസ്സിൽ വെച്ച് ആ രൂപം പാഴ്സ് ചെയ്യുക.
ടണൽ സ്വീകരിച്ചാൽ, വിജയകരമായ HTTP പ്രതികരണവും അത് അവസാനിപ്പിക്കുന്ന ശൂന്യ വരിയും അയയ്ക്കുക. തുടർന്ന് ക്ലയന്റ് സോക്കറ്റിൽ നിന്നുള്ള പിന്നീടുള്ള ബൈറ്റുകളുമായി തുടരുന്നതിന് മുമ്പ് ഏതെങ്കിലും head ബൈറ്റുകൾ അപ്സ്ട്രീമിലേക്ക് അയയ്ക്കുക. പുതിയ ഡാറ്റ ലിസണർ ഘടിപ്പിച്ച് ഇതിനകം ഹാൻഡ്ലർക്ക് വെവ്വേറെ നൽകിയ ബഫർ വീണ്ടെടുക്കാൻ കഴിയില്ല.
Node-ന്റെ ഔദ്യോഗിക ടണലിംഗ് ഉദാഹരണം രണ്ട് സ്ട്രീം ദിശകൾ ബന്ധിപ്പിക്കുന്നതിന് മുമ്പ് serverSocket.write(head) ഉപയോഗിച്ച് ആ കൈമാറ്റം നടത്തുന്നു. അതിന്റെ ചെറിയ ഉദാഹരണം പരിവർത്തനം വ്യക്തമാക്കുന്നു; വിന്യസിച്ച പ്രോക്സിക്ക് പരിമിതമായ കണക്ഷൻ ശ്രമങ്ങൾ, ആക്സസ് നിയന്ത്രണങ്ങൾ, ലൈഫ്സൈക്കിൾ കൈകാര്യം എന്നിവയും ആവശ്യമാണ്.
വിജയത്തിന് ശേഷം, ബൈറ്റുകൾ സേവന പ്രോട്ടോക്കോളിന്റേതാണ്
വിജയകരമായ CONNECT പ്രതികരണം കണക്ഷനെ ബൈറ്റ് സ്ട്രീമാക്കി മാറ്റുന്നു. ലക്ഷ്യം HTTPS സൈറ്റാണെങ്കിൽ, അതിന്റെ TLS കൈമാറ്റം ആ സ്ട്രീമിനുള്ളിൽ സഞ്ചരിക്കുന്നു. വെറുതെ ടണൽ ചെയ്യുന്നത് പ്രോക്സി പകരം വെബ്സൈറ്റ് സർട്ടിഫിക്കറ്റ് നൽകണമെന്ന് ആവശ്യപ്പെടുന്നില്ല.
CONNECT സ്വീകരിക്കുന്നതിന് മുമ്പ്, HTTP പിശക് നിരസിച്ചതിന്റെ കാരണം വിശദീകരിക്കാം. സ്വീകരിച്ചതിന് ശേഷം, സ്ട്രീമിലേക്ക് HTTP 500 എഴുതുന്നത് ടണൽ പ്രോട്ടോക്കോളിലേക്ക് ബൈറ്റുകൾ കുത്തിവയ്ക്കും. പകരം, പിന്നീടുള്ള പരാജയങ്ങളിൽ ഉചിതമായ കണക്ഷനുകൾ അവസാനിപ്പിക്കുകയോ നശിപ്പിക്കുകയോ ചെയ്യുക.
ഇരു ദിശകളും ബാക്ക്പ്രഷർ-ബോധ്യമുള്ള സ്ട്രീം കൈകാര്യം ഉപയോഗിച്ച് ബന്ധിപ്പിക്കുക, end, error, close ഇവന്റുകൾ എങ്ങനെ സഹചരനെ അവസാനിപ്പിക്കുന്നുവെന്ന് തീരുമാനിക്കുക. പ്രാരംഭ head ബഫർ അതേ ഉടമസ്ഥതാ മോഡലിന്റെ ഭാഗമായി സംരക്ഷിക്കുക; അത് ആപ്ലിക്കേഷൻ ഡാറ്റയാണ്, വലിച്ചെറിയേണ്ട അധിക HTTP ഹെഡറുകളല്ല.