haproxy-lua - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

haproxy-lua - haproxy-lua ഡോക്യുമെന്റേഷൻ

ഹാപ്രോക്സി ലുഅ പ്രവർത്തിക്കുന്ന സന്ദർഭങ്ങൾ

HAProxy-യിൽ നടപ്പിലാക്കിയ Lua കോഡ് 2 പ്രധാന മോഡുകളിൽ പ്രോസസ്സ് ചെയ്യാൻ കഴിയും. ആദ്യത്തേത്
പ്രാരംഭം മോഡ്, രണ്ടാമത്തേത് റൺടൈം മോഡ്.

· ഇതിൽ പ്രാരംഭം മോഡ്, ഞങ്ങൾക്ക് DNS സോൾവുകൾ നടത്താൻ കഴിയും, എന്നാൽ സോക്കറ്റ് I/O ചെയ്യാൻ ഞങ്ങൾക്ക് കഴിയില്ല.
ഈ ഇനീഷ്യലൈസേഷൻ മോഡിൽ, ലുവായുടെ നിർവ്വഹണ വേളയിൽ HAProxy ഇപ്പോഴും തടഞ്ഞു
പ്രോഗ്രാം.

· ഇതിൽ റൺടൈം മോഡ്, ഞങ്ങൾക്ക് DNS സോൾവുകൾ നടത്താൻ കഴിയില്ല, പക്ഷേ നമുക്ക് സോക്കറ്റുകൾ ഉപയോഗിക്കാം. ദി
ലുവാ കോഡിന്റെ നിർവ്വഹണം അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനൊപ്പം മൾട്ടിപ്ലക്സ് ചെയ്തിരിക്കുന്നു, അതിനാൽ ലുവാ കോഡ്
തടയുന്നതിൽ പ്രവർത്തിക്കുന്നതായി തോന്നുന്നു, പക്ഷേ അത് അങ്ങനെയല്ല.

Lua കോഡ് ഒന്നോ അതിലധികമോ ഫയലുകളിൽ ലോഡ് ചെയ്‌തിരിക്കുന്നു. ഈ ഫയലുകളിൽ പ്രധാന കോഡും പ്രവർത്തനങ്ങളും അടങ്ങിയിരിക്കുന്നു.
ലുവയ്ക്ക് 6 നിർവ്വഹണ സന്ദർഭമുണ്ട്.

1. ലുവാ ഫയൽ ശരീരം സന്ദർഭം. ലുവാ ഫയലിന്റെ ലോഡ് സമയത്ത് ഇത് എക്സിക്യൂട്ട് ചെയ്യുന്നു
HAProxy [ആഗോള] നിർദ്ദേശം ഉള്ള വിഭാഗം lua-ലോഡ്. ഇനീഷ്യലേഷനിൽ ഇത് നടപ്പിലാക്കുന്നു
മോഡ്. HAProxy-യിൽ Lua ബൈൻഡിംഗുകൾ ക്രമീകരിക്കുന്നതിന് ഈ വിഭാഗം ഉപയോഗിക്കുന്നു.

2. ലുവാ ഇവയെ സന്ദർഭം. HAProxy ന് തൊട്ടുപിന്നാലെ നടപ്പിലാക്കിയ ഒരു Lua ഫംഗ്‌ഷനാണിത്
കോൺഫിഗറേഷൻ പാഴ്‌സിംഗ്. എക്സിക്യൂഷൻ ഇനീഷ്യലൈസേഷൻ മോഡിലാണ്. ഈ പശ്ചാത്തലത്തിൽ ദി
HAProxy എൻവയോൺമെന്റ് ഇതിനകം ആരംഭിച്ചിട്ടുണ്ട്. കോൺഫിഗറേഷൻ പരിശോധിക്കുന്നത് ഉപയോഗപ്രദമാണ്, അല്ലെങ്കിൽ
സോക്കറ്റ് കണക്ഷനുകൾ അല്ലെങ്കിൽ ടാസ്ക്കുകൾ ആരംഭിക്കുന്നു. ഈ പ്രവർത്തനങ്ങൾ ശരീരത്തിൽ പ്രഖ്യാപിക്കപ്പെടുന്നു
Lua ഫംഗ്‌ഷനുമായുള്ള സന്ദർഭം core.register_init(). ഫംഗ്ഷന്റെ പ്രോട്ടോടൈപ്പ് a ആണ്
റിട്ടേൺ മൂല്യം കൂടാതെ പാരാമീറ്ററുകൾ ഇല്ലാതെ ലളിതമായ പ്രവർത്തനം, ഇതുപോലുള്ള: ഫംഗ്ഷൻ fcn().

3. ലുവാ ടാസ്ക് സന്ദർഭം. HAProxy ആരംഭിച്ചതിന് ശേഷം നടപ്പിലാക്കിയ ഒരു Lua ഫംഗ്‌ഷനാണിത്
ഷെഡ്യൂളർ, കൂടാതെ ലുവാ ഫംഗ്‌ഷനോടുകൂടിയ ടാസ്‌ക് പ്രഖ്യാപനത്തിന് തൊട്ടുപിന്നാലെ
core.register_task(). ഈ സന്ദർഭം ട്രാഫിക് പ്രോസസ്സിംഗുമായി സമാന്തരമാകാം. അത്
റൺടൈം മോഡിൽ എക്സിക്യൂട്ട് ചെയ്തു. ഫംഗ്‌ഷന്റെ പ്രോട്ടോടൈപ്പ് ഇല്ലാത്ത ഒരു ലളിതമായ ഫംഗ്‌ഷനാണ്
റിട്ടേൺ മൂല്യവും പാരാമീറ്ററുകൾ ഇല്ലാതെയും, ഇതുപോലെ: ഫംഗ്ഷൻ fcn().

4. എസ് നടപടി സന്ദർഭം. സോപാധികമായി നടപ്പിലാക്കിയ ഒരു ലുവാ ഫംഗ്‌ഷനാണിത്. ഈ പ്രവർത്തനങ്ങൾ
Lua നിർദ്ദേശങ്ങൾ പ്രകാരം രജിസ്റ്റർ ചെയ്തു "core.register_action()". ലുവയുടെ പ്രോട്ടോടൈപ്പ്
ഫംഗ്‌ഷൻ എന്ന് വിളിക്കുന്നത്, ഒന്നും തിരികെ നൽകാത്തതും ഒരു വസ്തുവിനെ എടുക്കുന്നതുമായ ഒരു ഫംഗ്‌ഷനാണ്
എൻട്രിയായി ക്ലാസ് TXN. ഫംഗ്ഷൻ fcn(txn).

5. എസ് സാമ്പിൾ-എടുക്കുക സന്ദർഭം. ഈ ഫംഗ്‌ഷൻ ഒരു TXN ഒബ്‌ജക്‌റ്റ് എൻട്രി ആർഗ്യുമെന്റായി എടുക്കുന്നു
ഒരു സ്ട്രിംഗ് തിരികെ നൽകുന്നു. ഇത്തരത്തിലുള്ള ഫംഗ്‌ഷനുകൾക്ക് ഒരു ബ്ലോക്ക് ചെയ്യുന്ന ഫംഗ്‌ഷനും എക്‌സിക്യൂട്ട് ചെയ്യാൻ കഴിയില്ല. അവർ
ഒറിജിനൽ HAProxy സാമ്പിൾ-ഫെച്ചുകളിൽ ചിലത് സംഗ്രഹിക്കാനും ഫലം നൽകാനും ഉപയോഗപ്രദമാണ്.
ഫംഗ്ഷന്റെ പ്രോട്ടോടൈപ്പ് ആണ് ഫംഗ്ഷൻ സ്ട്രിംഗ് fcn(txn). ഈ പ്രവർത്തനങ്ങൾ ആകാം
Lua ഫംഗ്ഷനിൽ രജിസ്റ്റർ ചെയ്തു core.register_fetches(). ഓരോ പ്രഖ്യാപിത സാമ്പിൾ-പിടിക്കലും ആണ്
"lua" എന്ന സ്ട്രിംഗിന്റെ പ്രിഫിക്‌സ്.

കുറിപ്പ്: ഈ ഫംഗ്‌ഷന് ആവശ്യമായ ഡാറ്റ ഒറിജിനലിൽ കണ്ടെത്താൻ കഴിയില്ല
HAProxy സാമ്പിൾ-ഫീച്ചുകൾ, ഈ സാഹചര്യത്തിൽ, ഇതിന് ഫലം നൽകാനാവില്ല. ഈ കേസ് ഇതുവരെ ഉണ്ടായിട്ടില്ല
പിന്തുണയ്ക്കുന്നു

6. എസ് കൺവെർട്ടർ സന്ദർഭം. ഒരു സ്ട്രിംഗ് ഇൻപുട്ടായി എടുത്ത് തിരികെ നൽകുന്ന ഒരു ലുവാ ഫംഗ്‌ഷനാണിത്
ഔട്ട്പുട്ടായി മറ്റൊരു സ്ട്രിംഗ്. ഇത്തരത്തിലുള്ള ഫംഗ്‌ഷനുകൾ സ്‌റ്റേറ്റ്‌ലെസ് ആണ്, അതിന് ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല
ഏതെങ്കിലും സന്ദർഭം. അവർ ഒരു തടയൽ ഫംഗ്‌ഷനും നിർവ്വഹിക്കുന്നില്ല. കോൾ പ്രോട്ടോടൈപ്പ് ആണ് ഫംഗ്ഷൻ
സ്ട്രിംഗ് fcn(സ്ട്രിംഗ്). ഈ ഫംഗ്‌ഷൻ Lua ഫംഗ്‌ഷനിൽ രജിസ്റ്റർ ചെയ്യാം
core.register_converters(). ഓരോ പ്രഖ്യാപിത കൺവെർട്ടറിനും "lua" എന്ന സ്ട്രിംഗ് പ്രിഫിക്‌സ് ചെയ്യുന്നു.

ഹാപ്രോക്സി ലുഅ ഹലോ ലോകം

HAProxy കോൺഫിഗറേഷൻ ഫയൽ (hello_world.conf):

ഗ്ലോബൽ
lua-load hello_world.lua

പ്രോക്സി കേൾക്കുക
ബൈൻഡ് 127.0.0.1:10001
tcp-അഭ്യർത്ഥന പരിശോധന-കാലതാമസം 1s
tcp-അഭ്യർത്ഥന ഉള്ളടക്ക ഉപയോഗം-സേവനം lua.hello_world

HAProxy Lua ഫയൽ (hello_world.lua):

core.register_service("hello_world", "tcp", function(applet)
applet:send("ഹലോ വേൾഡ്\n")
അവസാനിക്കുന്നു)

ഈ കോൺഫിഗറേഷൻ പരിശോധിക്കുന്നതിനായി HAProxy എങ്ങനെ ആരംഭിക്കാം:

./haproxy -f hello_world.conf

മറ്റ് ടെർമിനലിൽ, നിങ്ങൾക്ക് ടെൽനെറ്റ് ഉപയോഗിച്ച് പരീക്ഷിക്കാം:

#:~ ടെൽനെറ്റ് 127.0.0.1 10001
ഹലോ വേൾഡ്

ക്ലാസ് കോർ()
"കോർ" ക്ലാസിൽ എല്ലാ HAProxy കോർ ഫംഗ്ഷനുകളും അടങ്ങിയിരിക്കുന്നു. ഈ പ്രവർത്തനങ്ങൾ ഉപയോഗപ്രദമാണ്
എക്സിക്യൂഷൻ ഫ്ലോ നിയന്ത്രിക്കുന്നതിനും കൊളുത്തുകൾ രജിസ്റ്റർ ചെയ്യുന്നതിനും ആഗോള ഭൂപടങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനും
അല്ലെങ്കിൽ ACL,...

"core" ക്ലാസ് അടിസ്ഥാനപരമായി HAProxy ഉപയോഗിച്ചാണ് നൽകിയിരിക്കുന്നത്. ഇല്ല ആവശ്യമുണ്ട് ലൈൻ ആവശ്യമാണ്
ഈ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നു.

"കോർ" ക്ലാസ് സ്റ്റാറ്റിക് ആണ്, ഈ തരത്തിലുള്ള ഒരു പുതിയ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ സാധ്യമല്ല.

core.emerg

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ഈ ആട്രിബ്യൂട്ട് ഒരു പൂർണ്ണസംഖ്യയാണ്, അതിൽ ലോഗ്‌ലെവൽ "അടിയന്തരാവസ്ഥ" യുടെ മൂല്യം അടങ്ങിയിരിക്കുന്നു
(0).

core.alert

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ഈ ആട്രിബ്യൂട്ട് ഒരു പൂർണ്ണസംഖ്യയാണ്, അതിൽ ലോഗ്‌ലെവൽ "അലേർട്ട്" (1) ന്റെ മൂല്യം അടങ്ങിയിരിക്കുന്നു.

core.crit

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ഈ ആട്രിബ്യൂട്ട് ഒരു പൂർണ്ണസംഖ്യയാണ്, അതിൽ ലോഗ് ലെവൽ "ക്രിട്ടിക്കൽ" (2) മൂല്യം അടങ്ങിയിരിക്കുന്നു.

core.err

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ഈ ആട്രിബ്യൂട്ട് ഒരു പൂർണ്ണസംഖ്യയാണ്, അതിൽ ലോഗ്‌ലെവൽ "പിശക്" (3) ന്റെ മൂല്യം അടങ്ങിയിരിക്കുന്നു.

കോർ.മുന്നറിയിപ്പ്

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ഈ ആട്രിബ്യൂട്ട് ഒരു പൂർണ്ണസംഖ്യയാണ്, അതിൽ ലോഗ്‌ലെവൽ "മുന്നറിയിപ്പ്" (4) ന്റെ മൂല്യം അടങ്ങിയിരിക്കുന്നു.

core.notice

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ഈ ആട്രിബ്യൂട്ട് ഒരു പൂർണ്ണസംഖ്യയാണ്, അതിൽ ലോഗ്‌ലെവൽ "നോട്ടീസ്" (5) മൂല്യം അടങ്ങിയിരിക്കുന്നു.

core.info

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ഈ ആട്രിബ്യൂട്ട് ഒരു പൂർണ്ണസംഖ്യയാണ്, അതിൽ ലോഗ്‌ലെവൽ "ഇൻഫോ" (6) മൂല്യം അടങ്ങിയിരിക്കുന്നു.

core.debug

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ഈ ആട്രിബ്യൂട്ട് ഒരു പൂർണ്ണസംഖ്യയാണ്, അതിൽ ലോഗ് ലെവൽ "ഡീബഗ്" (7) മൂല്യം അടങ്ങിയിരിക്കുന്നു.

core.log(ലോഗ് ലെവൽ, സന്ദേശം)
സന്ദർഭം: ബോഡി, ഇനിറ്റ്, ടാസ്‌ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

ഈ പ്രവർത്തനം ഒരു ലോഗ് അയയ്ക്കുന്നു. HAProxy അനുസരിച്ച് ലോഗ് അയച്ചു
കോൺഫിഗറേഷൻ ഫയൽ, അത് കോൺഫിഗർ ചെയ്തിട്ടുണ്ടെങ്കിൽ സ്ഥിരസ്ഥിതി syslog സെർവറിൽ
അത് അനുവദനീയമാണെങ്കിൽ stderr.

വാദങ്ങൾ

· ലോഗ് ലെവൽ (പൂർണ്ണസംഖ്യ) -- ലോഗ് ലെവൽ സന്ദേശവുമായി ബന്ധപ്പെട്ടതാണോ. ഇത് എ
0 നും 7 നും ഇടയിലുള്ള സംഖ്യ.

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക core.emerg, core.alert, core.crit, core.err, core.warning, core.notice,
core.info, core.debug (ലോഗ് ലെവൽ നിർവചനങ്ങൾ)

കാണുക കോഡ്.ഡീബഗ്

കാണുക core.Info

കാണുക കോർ.മുന്നറിയിപ്പ്

കാണുക കോർ.അലേർട്ട്

കോർ.ഡീബഗ്(സന്ദേശം)
സന്ദർഭം: ബോഡി, ഇനിറ്റ്, ടാസ്‌ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

വാദങ്ങൾ

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക ലോഗ്

ഇനിപ്പറയുന്നതിനേക്കാൾ ഒരേ ജോലി ചെയ്യുന്നു:

ഫംഗ്ഷൻ ഡീബഗ് ചെയ്യുക(സന്ദേശം)
core.log(core.debug, msg)
അവസാനിക്കുന്നു

core.Info(സന്ദേശം)
സന്ദർഭം: ബോഡി, ഇനിറ്റ്, ടാസ്‌ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

വാദങ്ങൾ

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക ലോഗ്

ഫംഗ്ഷൻ വിവരം(സന്ദേശം)
core.log(core.info, msg)
അവസാനിക്കുന്നു

കോർ.മുന്നറിയിപ്പ്(സന്ദേശം)
സന്ദർഭം: ബോഡി, ഇനിറ്റ്, ടാസ്‌ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

വാദങ്ങൾ

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക ലോഗ്

ഫംഗ്ഷൻ മുന്നറിയിപ്പ്(സന്ദേശം)
core.log(core.warning, msg)
അവസാനിക്കുന്നു

കോർ.അലേർട്ട്(സന്ദേശം)
സന്ദർഭം: ബോഡി, ഇനിറ്റ്, ടാസ്‌ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

വാദങ്ങൾ

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക ലോഗ്

ഫംഗ്ഷൻ അലേർട്ട്(സന്ദേശം)
core.log(core.alert, msg)
അവസാനിക്കുന്നു

core.add_acl(ഫയലിന്റെ പേര്, കീ)
സന്ദർഭം: init, ടാസ്ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

ACL ചേർക്കുക കീ ഫയൽ റഫറൻസ് ചെയ്ത ACLs ലിസ്റ്റിൽ ഫയലിന്റെ പേര്.

വാദങ്ങൾ

· ഫയലിന്റെ പേര് (സ്ട്രിംഗ്) -- ACL എൻട്രികളെ പരാമർശിക്കുന്ന ഫയൽ നാമം.

· കീ (സ്ട്രിംഗ്) -- ചേർക്കുന്ന കീ.

core.del_acl(ഫയലിന്റെ പേര്, കീ)
സന്ദർഭം: init, ടാസ്ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

കീ പരാമർശിച്ചിരിക്കുന്ന ACL എൻട്രി ഇല്ലാതാക്കുക കീ റഫറൻസ് ചെയ്ത ACL-കളുടെ പട്ടികയിൽ
ഫയലിന്റെ പേര്.

വാദങ്ങൾ

· ഫയലിന്റെ പേര് (സ്ട്രിംഗ്) -- ACL എൻട്രികളെ പരാമർശിക്കുന്ന ഫയൽ നാമം.

· കീ (സ്ട്രിംഗ്) -- ഇല്ലാതാക്കപ്പെടുന്ന കീ.

core.del_map(ഫയലിന്റെ പേര്, കീ)
സന്ദർഭം: init, ടാസ്ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

റഫറൻസ് ചെയ്ത മാപ്പുകളുടെ പട്ടികയിലെ നിർദ്ദിഷ്ട കീ ഉപയോഗിച്ച് സൂചികയിലാക്കിയ മാപ്പ് എൻട്രി ഇല്ലാതാക്കുക
അവന്റെ ഫയൽ നാമത്തിൽ.

വാദങ്ങൾ

· ഫയലിന്റെ പേര് (സ്ട്രിംഗ്) -- മാപ്പ് എൻട്രികളെ പരാമർശിക്കുന്ന ഫയൽ നാമം.

· കീ (സ്ട്രിംഗ്) -- ഇല്ലാതാക്കപ്പെടുന്ന കീ.

core.msleep(മില്ലിസെക്കൻഡ്)
സന്ദർഭം: ശരീരം, init, ചുമതല, പ്രവർത്തനം

ദി core.msleep() നിർദ്ദിഷ്ട മില്ലിസെക്കൻഡുകൾക്കിടയിൽ Lua എക്സിക്യൂഷൻ നിർത്തുന്നു.

വാദങ്ങൾ

· മില്ലിസെക്കൻഡ് (പൂർണ്ണസംഖ്യ) -- ആവശ്യമായ മില്ലിസെക്കൻഡ്.

core.register_action(പേര്, പ്രവർത്തനങ്ങൾ, ഫങ്ക്)
സന്ദർഭം: ശരീരം

പ്രവർത്തനമായി നടപ്പിലാക്കിയ ഒരു ലുവാ ഫംഗ്‌ഷൻ രജിസ്റ്റർ ചെയ്യുക. രജിസ്റ്റർ ചെയ്ത എല്ലാ പ്രവർത്തനങ്ങളും ഉപയോഗിക്കാം
HAProxy-ൽ "lua" എന്ന പ്രിഫിക്‌സ്. ഒരു പ്രവർത്തനത്തിന് ഇൻപുട്ടായി TXN ഒബ്ജക്റ്റ് ക്ലാസ് ലഭിക്കുന്നു.

വാദങ്ങൾ

· പേര് (സ്ട്രിംഗ്) -- എന്നത് കൺവെർട്ടറിന്റെ പേരാണ്.

· ഓഹരി (മേശ) -- HAProxy പ്രവർത്തനങ്ങളെ വിവരിക്കുന്ന സ്ട്രിംഗ് പട്ടികയാണ്
രജിസ്റ്റർ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു. പ്രതീക്ഷിക്കുന്ന പ്രവർത്തനങ്ങൾ 'tcp-req', 'tcp-res' എന്നിവയാണ്,
'http-req' അല്ലെങ്കിൽ 'http-res'.

· ഫങ്ക് (ഫംഗ്ഷൻ) -- കൺവെർട്ടറായി പ്രവർത്തിക്കാൻ വിളിക്കപ്പെടുന്ന Lua ഫംഗ്‌ഷൻ ആണ്.

ആർഗ്യുമെന്റായി ഉപയോഗിക്കുന്ന ലുവാ ഫംഗ്‌ഷന്റെ പ്രോട്ടോടൈപ്പ് ഇതാണ്:

ഫംഗ്‌ഷൻ (txn)

·

txn (TXN ക്ലാസ്): ഈ is a TXN വസ്തു ഉപയോഗിച്ച വേണ്ടി കൈകാര്യം ചെയ്യുന്നു The
നിലവിലെ അഭ്യർത്ഥന അല്ലെങ്കിൽ TCP സ്ട്രീം.

ഇവിടെ, പ്രവർത്തന രജിസ്ട്രേഷന്റെ ഒരു ഉദാഹരണം. ആക്ഷൻ ജസ്റ്റ് ഒരു 'ഹലോ വേൾഡ്' അയയ്ക്കുന്നു
ലോഗുകൾ.

core.register_action("ഹലോ-വേൾഡ്", { "tcp-req", "http-req"}, ഫംഗ്‌ഷൻ(txn)
txn:Info("ഹലോ വേൾഡ്")
അവസാനിക്കുന്നു)
ഈ ഉദാഹരണ കോഡ് ഇതുപോലെയുള്ള HAproxy കോൺഫിഗറേഷനിൽ ഉപയോഗിക്കുന്നു:

മുൻഭാഗം tcp_frt
മോഡ് tcp
tcp-അഭ്യർത്ഥന ഉള്ളടക്കം lua.hello-world

മുൻഭാഗം http_frt
മോഡ് http
http-request lua.hello-world

core.register_converters(പേര്, ഫങ്ക്)
സന്ദർഭം: ശരീരം

കൺവെർട്ടറായി ഒരു Lua ഫംഗ്‌ഷൻ രജിസ്റ്റർ ചെയ്യുക. രജിസ്റ്റർ ചെയ്ത എല്ലാ കൺവെർട്ടറുകളും ആകാം
"lua" എന്ന പ്രിഫിക്‌സിനൊപ്പം HAProxy-യിൽ ഉപയോഗിക്കുന്നു. ഒരു കൺവെർട്ടറിന് ഇൻപുട്ടായി ഒരു സ്ട്രിംഗ് ലഭിക്കും
ഔട്ട്പുട്ടായി ഒരു സ്ട്രിംഗ് തിരികെ നൽകുക. രജിസ്റ്റർ ചെയ്ത പ്രവർത്തനത്തിന് 9 മൂല്യങ്ങൾ വരെ എടുക്കാം
പരാമീറ്റർ. എല്ലാ മൂല്യങ്ങളും സ്ട്രിംഗുകളാണ്.

വാദങ്ങൾ

· പേര് (സ്ട്രിംഗ്) -- എന്നത് കൺവെർട്ടറിന്റെ പേരാണ്.

· ഫങ്ക് (ഫംഗ്ഷൻ) -- കൺവെർട്ടറായി പ്രവർത്തിക്കാൻ വിളിക്കപ്പെടുന്ന Lua ഫംഗ്‌ഷൻ ആണ്.

ആർഗ്യുമെന്റായി ഉപയോഗിക്കുന്ന ലുവാ ഫംഗ്‌ഷന്റെ പ്രോട്ടോടൈപ്പ് ഇതാണ്:

ഫംഗ്‌ഷൻ(str, [p1 [, p2 [, ... [, p5]]]])

· str (സ്ട്രിംഗ്): ഇത് സ്ട്രിംഗിൽ യാന്ത്രികമായി പരിവർത്തനം ചെയ്യപ്പെടുന്ന ഇൻപുട്ട് മൂല്യമാണ്.

· p1 .. p5 (സ്ട്രിംഗ്): ഇത് ഹാറോക്സിയിൽ പ്രഖ്യാപിച്ച സ്ട്രിംഗ് ആർഗ്യുമെന്റുകളുടെ ഒരു പട്ടികയാണ്
കോൺഫിഗറേഷൻ ഫയൽ. ആർഗ്യുമെന്റുകളുടെ എണ്ണം 5 കവിയരുത്. ക്രമവും
ഇവയുടെ സ്വഭാവം പരമ്പരാഗതമായി ഡെവലപ്പർ തിരഞ്ഞെടുക്കുന്നു.

core.register_fetches(പേര്, ഫങ്ക്)
സന്ദർഭം: ശരീരം

സാമ്പിൾ എടുക്കൽ എന്ന നിലയിൽ ഒരു ലുവാ ഫംഗ്‌ഷൻ രജിസ്റ്റർ ചെയ്യുക. രജിസ്റ്റർ ചെയ്ത എല്ലാ സാമ്പിളും എടുക്കുന്നു
"lua" എന്ന പ്രിഫിക്‌സിനൊപ്പം HAProxy-യിൽ ഉപയോഗിക്കാം. ഒരു ലുവാ സാമ്പിൾ എടുക്കൽ ഒരു സ്ട്രിംഗ് തിരികെ നൽകുന്നു
ഔട്ട്പുട്ട് ആയി. രജിസ്റ്റർ ചെയ്ത പ്രവർത്തനത്തിന് 9 മൂല്യങ്ങൾ വരെ പാരാമീറ്ററായി എടുക്കാം. എല്ലാ
മൂല്യം സ്ട്രിംഗുകളാണ്.

വാദങ്ങൾ

· പേര് (സ്ട്രിംഗ്) -- എന്നത് കൺവെർട്ടറിന്റെ പേരാണ്.

· ഫങ്ക് (ഫംഗ്ഷൻ) -- സാമ്പിൾ എടുക്കൽ ആയി പ്രവർത്തിക്കാൻ വിളിക്കപ്പെടുന്ന Lua ഫംഗ്‌ഷൻ ആണ്.

ആർഗ്യുമെന്റായി ഉപയോഗിക്കുന്ന ലുവാ ഫംഗ്‌ഷന്റെ പ്രോട്ടോടൈപ്പ് ഇതാണ്:

സ്ട്രിംഗ് ഫംഗ്‌ഷൻ(txn, [p1 [, p2 [, ... [, p5]]]])

· txn (TXN ക്ലാസ്): നിലവിലെ അഭ്യർത്ഥനയുമായി ബന്ധപ്പെട്ട txn ഒബ്ജക്റ്റാണിത്.

· p1 .. p5 (സ്ട്രിംഗ്): ഇത് ഹാറോക്സിയിൽ പ്രഖ്യാപിച്ച സ്ട്രിംഗ് ആർഗ്യുമെന്റുകളുടെ ഒരു പട്ടികയാണ്
കോൺഫിഗറേഷൻ ഫയൽ. ആർഗ്യുമെന്റുകളുടെ എണ്ണം 5 കവിയരുത്. ക്രമവും
ഇവയുടെ സ്വഭാവം പരമ്പരാഗതമായി ഡെവലപ്പർ തിരഞ്ഞെടുക്കുന്നു.

· റിട്ടേൺസ്: ചില ഡാറ്റ അടങ്ങുന്ന ഒരു സ്ട്രിംഗ്, മൂല്യം ഇപ്പോൾ തിരികെ നൽകാൻ കഴിയുന്നില്ലെങ്കിൽ ഒട്ടി ഇല്ല.

lua ഉദാഹരണ കോഡ്:

core.register_fetches("ഹലോ", ഫംഗ്‌ഷൻ(txn)
"ഹലോ" തിരികെ
അവസാനിക്കുന്നു)
HAProxy ഉദാഹരണ കോൺഫിഗറേഷൻ:

മുൻഭാഗം ഉദാഹരണം
http-request redirect location /%[lua.hello]

core.register_service(പേര്, മോഡ്, ഫങ്ക്)
സന്ദർഭം: ശരീരം

ഒരു സേവനമായി നടപ്പിലാക്കിയ ഒരു Lua ഫംഗ്‌ഷൻ രജിസ്റ്റർ ചെയ്യുക. രജിസ്റ്റർ ചെയ്ത എല്ലാ സേവനങ്ങളും ആകാം
"lua" എന്ന പ്രിഫിക്‌സിനൊപ്പം HAProxy-യിൽ ഉപയോഗിക്കുന്നു. ഒരു സേവനത്തിന് ഇൻപുട്ടായി ഒരു ഒബ്ജക്റ്റ് ക്ലാസ് ലഭിക്കുന്നു
ആവശ്യമായ മോഡ് അനുസരിച്ച്.

വാദങ്ങൾ

· പേര് (സ്ട്രിംഗ്) -- എന്നത് കൺവെർട്ടറിന്റെ പേരാണ്.

· മോഡ് (സ്ട്രിംഗ്) -- ആവശ്യമായ മോഡ് വിവരിക്കുന്ന സ്ട്രിംഗ് ആണ്. 'tcp' മാത്രം അല്ലെങ്കിൽ
'http' അനുവദനീയമാണ്.

· ഫങ്ക് (ഫംഗ്ഷൻ) -- കൺവെർട്ടറായി പ്രവർത്തിക്കാൻ വിളിക്കപ്പെടുന്ന Lua ഫംഗ്‌ഷൻ ആണ്.

ആർഗ്യുമെന്റായി ഉപയോഗിക്കുന്ന ലുവാ ഫംഗ്‌ഷന്റെ പ്രോട്ടോടൈപ്പ് ഇതാണ്:

പ്രവർത്തനം (ആപ്ലെറ്റ്)

· ആപ്ലെറ്റ് ആപ്ലെറ്റ് ഒരു ആയിരിക്കും AppletTCP ക്ലാസ് അല്ലെങ്കിൽ AppletHTTP ക്ലാസ്. ഇത് തരത്തെ ആശ്രയിച്ചിരിക്കുന്നു
രജിസ്റ്റർ ചെയ്ത ആപ്ലെറ്റിന്റെ. എന്നതിനായുള്ള 'http' മൂല്യത്തിൽ രജിസ്റ്റർ ചെയ്ത ഒരു ആപ്‌ലെറ്റ് മോഡ്
പരാമീറ്റർ a ലഭിക്കും AppletHTTP ക്ലാസ്. ആണെങ്കിൽ മോഡ് മൂല്യം 'tcp' ആണ്, ആപ്ലെറ്റ് ചെയ്യും
ഒരു ലഭിക്കുന്നു AppletTCP ക്ലാസ്.

മുന്നറിയിപ്പ്: 'http' എന്ന തരത്തിലുള്ള ആപ്ലെറ്റുകൾ 'tcp- ൽ നിന്ന് വിളിക്കാൻ കഴിയില്ല' നിയമങ്ങൾ. മാത്രം The 'http-'
റൂൾസെറ്റുകൾ അംഗീകൃതമാണ്, ഇതിനർത്ഥം a എന്നതിൽ നിന്ന് ഒരു HTTP ആപ്‌ലെറ്റിനെ വിളിക്കാൻ കഴിയില്ല എന്നാണ്
tcp മോഡിൽ പ്രോക്സി. 'tcp' എന്ന തരത്തിലുള്ള ആപ്‌ലെറ്റുകൾ എവിടെ നിന്നും വിളിക്കാം.

ഇവിടെ, സേവന രജിസ്ട്രേഷന്റെ ഒരു ഉദാഹരണം. ഈ സേവനം ഒരു 'ഹലോ വേൾഡ്' ആയി അയയ്ക്കുക
http പ്രതികരണം.

core.register_service("ഹലോ-വേൾഡ്", "http", ഫംഗ്‌ഷൻ(ആപ്‌ലെറ്റ്)
പ്രാദേശിക പ്രതികരണം = "ഹലോ വേൾഡ്!"
ആപ്ലെറ്റ്:സെറ്റ്_സ്റ്റാറ്റസ്(200)
applet:add_header("content-length", string.len(response))
applet:add_header("content-type", "text/plain")
applet:start_response()
applet:അയയ്ക്കുക(പ്രതികരണം)
അവസാനിക്കുന്നു)
ഈ ഉദാഹരണ കോഡ് ഇതുപോലെയുള്ള HAproxy കോൺഫിഗറേഷനിൽ ഉപയോഗിക്കുന്നു:

മുൻഭാഗം ഉദാഹരണം
http-request use-service lua.hello-world

core.register_init(func)
സന്ദർഭം: ശരീരം

കോൺഫിഗറേഷൻ പാഴ്സിംഗിന് ശേഷം എക്സിക്യൂട്ട് ചെയ്ത ഒരു ഫംഗ്ഷൻ രജിസ്റ്റർ ചെയ്യുക. ഇത് ഉപയോഗപ്രദമാണ്
ഏതെങ്കിലും പരാമീറ്ററുകൾ പരിശോധിക്കുക.

വാദങ്ങൾ

· ഫങ്ക് (ഫംഗ്ഷൻ) -- ഇനീഷ്യലൈസറായി പ്രവർത്തിക്കാൻ വിളിക്കപ്പെടുന്ന Lua ഫംഗ്‌ഷൻ ആണ്.

ആർഗ്യുമെന്റായി ഉപയോഗിക്കുന്ന ലുവാ ഫംഗ്‌ഷന്റെ പ്രോട്ടോടൈപ്പ് ഇതാണ്:

ഫംഗ്ഷൻ()
ഇതിന് ഇൻപുട്ട് ആവശ്യമില്ല, ഔട്ട്പുട്ടൊന്നും പ്രതീക്ഷിക്കുന്നില്ല.

core.register_task(func)
സന്ദർഭം: ബോഡി, ഇനിറ്റ്, ടാസ്‌ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

രജിസ്റ്റർ ചെയ്ത് സ്വതന്ത്ര ചുമതല ആരംഭിക്കുക. HAProxy മെയിൻ ചെയ്യുമ്പോൾ ടാസ്ക് ആരംഭിക്കുന്നു
ഷെഡ്യൂളർ ആരംഭിക്കുന്നു. ഉദാഹരണത്തിന്, ഇത്തരത്തിലുള്ള ജോലികൾ സങ്കീർണ്ണമായ രീതിയിൽ നിർവഹിക്കാൻ കഴിയും
ആരോഗ്യ പരിശോധനകൾ.

വാദങ്ങൾ

· ഫങ്ക് (ഫംഗ്ഷൻ) -- ഇനീഷ്യലൈസറായി പ്രവർത്തിക്കാൻ വിളിക്കപ്പെടുന്ന Lua ഫംഗ്‌ഷൻ ആണ്.

ആർഗ്യുമെന്റായി ഉപയോഗിക്കുന്ന ലുവാ ഫംഗ്‌ഷന്റെ പ്രോട്ടോടൈപ്പ് ഇതാണ്:

ഫംഗ്ഷൻ()
ഇതിന് ഇൻപുട്ട് ആവശ്യമില്ല, ഔട്ട്പുട്ടൊന്നും പ്രതീക്ഷിക്കുന്നില്ല.

core.set_nice(നല്ലത്)
സന്ദർഭം: ടാസ്ക്, പ്രവർത്തനം, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

നിലവിലെ ടാസ്‌ക്കിന്റെ അല്ലെങ്കിൽ നിലവിലെ സെഷന്റെ ഭംഗി മാറ്റുക.

വാദങ്ങൾ

· നൈസ് (പൂർണ്ണസംഖ്യ) -- നല്ല മൂല്യം, അത് -1024 നും 1024 നും ഇടയിലായിരിക്കണം.

core.set_map(ഫയലിന്റെ പേര്, കീ, മൂല്യം)
സന്ദർഭം: init, ടാസ്ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

മൂല്യം സജ്ജമാക്കുക മൂല്യം കീയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു കീ പരാമർശിച്ച ഭൂപടത്തിൽ ഫയലിന്റെ പേര്.

വാദങ്ങൾ

· ഫയലിന്റെ പേര് (സ്ട്രിംഗ്) -- മാപ്പ് റഫറൻസ്

· കീ (സ്ട്രിംഗ്) -- സജ്ജീകരിക്കാനോ മാറ്റിസ്ഥാപിക്കാനോ ഉള്ള കീ

· മൂല്യം (സ്ട്രിംഗ്) -- ബന്ധപ്പെട്ട മൂല്യം

core.sleep(int സെക്കൻഡ്)
സന്ദർഭം: ശരീരം, init, ചുമതല, പ്രവർത്തനം

ദി core.sleep() ഫംഗ്‌ഷനുകൾ നിർദ്ദിഷ്‌ട സെക്കൻഡുകൾക്കിടയിൽ Lua എക്‌സിക്യൂഷൻ നിർത്തുന്നു.

വാദങ്ങൾ

· നിമിഷങ്ങൾ (പൂർണ്ണസംഖ്യ) -- ആവശ്യമായ സെക്കന്റുകൾ.

core.tcp()
സന്ദർഭം: init, ചുമതല, പ്രവർത്തനം

ഈ ഫംഗ്‌ഷൻ a യുടെ ഒരു പുതിയ ഒബ്‌ജക്‌റ്റ് നൽകുന്നു സോക്കറ്റ് ക്ലാസ്.

റിട്ടേൺസ്
A സോക്കറ്റ് ക്ലാസ് വസ്തു

core.done(ഡാറ്റ)
സന്ദർഭം: ബോഡി, ഇനിറ്റ്, ടാസ്‌ക്, ആക്ഷൻ, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

വാദങ്ങൾ

· ഡാറ്റ (എന്തെങ്കിലും) -- കോളർക്കായി കുറച്ച് ഡാറ്റ തിരികെ നൽകുക. കൂടെ ഉപയോഗപ്രദമാണ്
സാമ്പിൾ-ഫെച്ചുകളും സാമ്പിൾ-കൺവെർട്ടറുകളും.

നിലവിലെ ലുവാ നിർവ്വഹണം ഉടനടി നിർത്തുകയും വിളിക്കുന്നയാളുടെ അടുത്തേക്ക് മടങ്ങുകയും ചെയ്യുന്നു
ഒരു സാമ്പിൾ എടുക്കൽ, ഒരു കൺവെർട്ടർ അല്ലെങ്കിൽ ഒരു പ്രവർത്തനം, കൂടാതെ നിർദ്ദിഷ്ട മൂല്യം തിരികെ നൽകുന്നു (അവഗണിച്ചു
പ്രവർത്തനങ്ങൾക്കായി). LUA പ്രോസസ്സ് അതിന്റെ ജോലി പൂർത്തിയാക്കി നൽകാൻ ആഗ്രഹിക്കുമ്പോൾ ഇത് ഉപയോഗിക്കുന്നു
ശേഷിക്കുന്ന കോഡ് എക്സിക്യൂട്ട് ചെയ്യാതെ തന്നെ നിയന്ത്രണം HAProxy-ലേക്ക് തിരികെ നൽകുക. എന്ന് കാണാം
ഒരു മൾട്ടി-ലെവൽ "റിട്ടേൺ".

core.yild()
സന്ദർഭം: ടാസ്ക്, പ്രവർത്തനം, സാമ്പിൾ-ഫെച്ച്, കൺവെർട്ടർ

HAProxy ഷെഡ്യൂളറിൽ കൈ തിരികെ നൽകുക. LUA പ്രോസസ്സ് ചെയ്യുമ്പോൾ ഇത് ഉപയോഗിക്കുന്നു
വളരെയധികം പ്രോസസ്സിംഗ് സമയം ചെലവഴിക്കുന്നു.

ക്ലാസ് ലഭ്യമാക്കുന്നു()
ഈ ക്ലാസിൽ ധാരാളം ആന്തരിക HAProxy സാമ്പിൾ ലഭ്യമാക്കലുകൾ അടങ്ങിയിരിക്കുന്നു. HAProxy കാണുക
അവളുടെ ഉപയോഗത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് "configuration.txt" ഡോക്യുമെന്റേഷൻ. അവർ
7.3.2 മുതൽ 7.3.6 വരെയുള്ള അധ്യായങ്ങൾ.

മുന്നറിയിപ്പ് ചില സന്ദർഭങ്ങളിൽ ചില സാമ്പിൾ ലഭ്യമാക്കലുകൾ ലഭ്യമല്ല. ഈ പരിമിതികൾ
അവ ഉപയോഗപ്രദമാകുമ്പോൾ ഈ ഡോക്യുമെന്റേഷനിൽ വ്യക്തമാക്കിയിരിക്കുന്നു.

കാണുക TXN.f

കാണുക TXN.sf

ലഭിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്:

· സിസ്റ്റം സമയം നേടുക,

പരിസ്ഥിതി വേരിയബിൾ നേടുക,

· ക്രമരഹിത സംഖ്യകൾ നേടുക,

· ക്യൂവിലുള്ള ഉപയോക്താക്കളുടെ എണ്ണം അല്ലെങ്കിൽ എണ്ണം പോലെ അറിയപ്പെടുന്ന ബാക്കെൻഡ് സ്റ്റാറ്റസ്
ബന്ധങ്ങൾ സ്ഥാപിച്ചു,

IP ഉറവിടം അല്ലെങ്കിൽ ലക്ഷ്യസ്ഥാനം പോലുള്ള ക്ലയന്റ് വിവരങ്ങൾ,

സ്റ്റിക്ക് ടേബിളുകൾ കൈകാര്യം ചെയ്യുക,

· സ്ഥാപിതമായ SSL വിവരങ്ങൾ,

ഹെഡറുകൾ അല്ലെങ്കിൽ രീതി പോലുള്ള HTTP വിവരങ്ങൾ.

ഫംഗ്‌ഷൻ പ്രവർത്തനം (txn)
-- ഉറവിട ഐപി നേടുക
പ്രാദേശിക ക്ലയന്റിപ്പ് = txn.f:src()
അവസാനിക്കുന്നു

ക്ലാസ് കൺവെർട്ടറുകൾ()
ഈ ക്ലാസിൽ ധാരാളം ആന്തരിക HAProxy സാമ്പിൾ കൺവെർട്ടറുകൾ അടങ്ങിയിരിക്കുന്നു. HAProxy കാണുക
അവളുടെ ഉപയോഗത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് ഡോക്യുമെന്റേഷൻ "configuration.txt". അത്രയേയുള്ളൂ
അധ്യായം 7.3.1.

കാണുക TXN.c

കാണുക TXN.sc

കൺവെർട്ടറുകൾ സംസ്ഥാന പൂർണ്ണമായ പരിവർത്തനം നൽകുന്നു. അവ ഉപയോഗപ്രദമാണ്:

ഇൻപുട്ട് ബേസ്64 ലേക്ക് പരിവർത്തനം ചെയ്യുന്നു,

ഇൻപുട്ട് സ്ട്രിംഗിൽ ഹാഷ് പ്രയോഗിക്കുന്നു (djb2, crc32, sdbm, wt6),

· ഫോർമാറ്റ് തീയതി,

· json രക്ഷപ്പെടൽ,

രണ്ട് ലിസ്‌റ്റുകൾ താരതമ്യം ചെയ്‌ത് തിരഞ്ഞെടുത്ത ഭാഷ എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നു,

· താഴ്ന്ന അല്ലെങ്കിൽ മുകളിലെ അക്ഷരങ്ങളിലേക്ക് തിരിയുക,

· സ്റ്റിക്ക് ടേബിളുകൾ കൈകാര്യം ചെയ്യുക.

ക്ലാസ് ചാനൽ()
അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് HAProxy രണ്ട് ബഫറുകൾ ഉപയോഗിക്കുന്നു. ആദ്യത്തേത് ഉപയോഗിക്കുന്നു
അഭ്യർത്ഥന ഡാറ്റയ്‌ക്കൊപ്പം (ക്ലയൻറിൽ നിന്ന് സെർവറിലേക്ക്) രണ്ടാമത്തേത് ഇതിനായി ഉപയോഗിക്കുന്നു
പ്രതികരണ ഡാറ്റ (സെർവറിൽ നിന്ന് ക്ലയന്റിലേക്ക്).

ഓരോ ബഫറിലും രണ്ട് തരം ഡാറ്റ അടങ്ങിയിരിക്കുന്നു. ആദ്യ തരം ഇൻകമിംഗ് ഡാറ്റ വെയ്റ്റിംഗ് ആണ്
ഒരു പ്രോസസ്സിംഗിനായി. രണ്ടാം ഭാഗം ഇതിനകം പ്രോസസ്സ് ചെയ്ത ഔട്ട്ഗോയിംഗ് ഡാറ്റയാണ്. സാധാരണയായി,
ഇൻകമിംഗ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യപ്പെടുന്നു, അത് ഔട്ട്ഗോയിംഗ് ഡാറ്റയായി ടാഗ് ചെയ്ത ശേഷം, ഒടുവിൽ അത്
അയച്ചിരിക്കുന്നു. ഈ ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ടൂളുകൾ ഇനിപ്പറയുന്ന ഫംഗ്ഷനുകൾ നൽകുന്നു a
ബഫർ.

ചാനൽ ക്ലാസ് ഫംഗ്‌ഷൻ എവിടെയാണ് പ്രയോഗിക്കുന്നതെന്ന് ഇനിപ്പറയുന്ന ഡയഗ്രം കാണിക്കുന്നു.

മുന്നറിയിപ്പ്: അഭ്യർത്ഥന പ്രവർത്തനത്തിലെ പ്രതികരണത്തിൽ നിന്ന് വായിക്കാൻ സാധ്യമല്ല, അത് അങ്ങനെയാണ്
പ്രതികരണ പ്രവർത്തനത്തിൽ അഭ്യർത്ഥന ചാനലിനായി വായിക്കാൻ സാധ്യമല്ല.
[ചിത്രം]

Channel.dup(ചാനൽ)
ഈ ഫംഗ്ഷൻ മുഴുവൻ ബഫറും അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു. ഡാറ്റ അല്ല
ബഫറിൽ നിന്ന് നീക്കം ചെയ്യുക, പിന്നീട് വീണ്ടും പ്രോസസ്സ് ചെയ്യാം.

ബഫറിന് കൂടുതൽ ഡാറ്റ സ്വീകരിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, ഒരു 'പൂജ്യം' മൂല്യം നൽകും.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

റിട്ടേൺസ്
ലഭ്യമായ എല്ലാ ഡാറ്റയും അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ ഇല്ല.

Channel.get(channel)
ഈ ഫംഗ്ഷൻ മുഴുവൻ ബഫറും അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു. ഡാറ്റ ഉപഭോഗം ചെയ്യുന്നു
ബഫറിൽ നിന്ന്.

ബഫറിന് കൂടുതൽ ഡാറ്റ സ്വീകരിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, ഒരു 'പൂജ്യം' മൂല്യം നൽകും.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

റിട്ടേൺസ്
ലഭ്യമായ എല്ലാ ഡാറ്റയും അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ ഇല്ല.

Channel.getline(ചാനൽ)
ഈ ഫംഗ്‌ഷൻ ബഫറിന്റെ ആദ്യ വരി അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു. ഡാറ്റ
ദഹിപ്പിക്കപ്പെടുന്നു. നൽകിയ ഡാറ്റയിൽ അന്തിമ 'n' അടങ്ങിയിട്ടില്ലെങ്കിൽ, അതിനെക്കാൾ അനുമാനിക്കപ്പെടുന്നു
ബഫറിൽ ലഭ്യമായ അവസാനത്തെ ഡാറ്റ.

ബഫറിന് കൂടുതൽ ഡാറ്റ സ്വീകരിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, ഒരു 'പൂജ്യം' മൂല്യം നൽകും.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

റിട്ടേൺസ്
ലഭ്യമായ ലൈൻ അല്ലെങ്കിൽ nil അടങ്ങുന്ന ഒരു സ്ട്രിംഗ്.

Channel.set(ചാനൽ, സ്ട്രിംഗ്)
ഈ ഫംഗ്‌ഷൻ ബഫറിന്റെ ഉള്ളടക്കത്തെ സ്ട്രിംഗ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ഫംഗ്ഷൻ മടങ്ങുന്നു
പകർത്തിയ ദൈർഘ്യം, അല്ലെങ്കിൽ, അത് -1 നൽകുന്നു.

ഈ ഫംഗ്‌ഷനുള്ള ഡാറ്റ സെറ്റ് അയയ്‌ക്കില്ല. അവർ HAProxy യുടെ അവസാനത്തിനായി കാത്തിരിക്കുന്നു
പ്രോസസ്സ് ചെയ്യുന്നു, അതിനാൽ ബഫർ പൂർണ്ണമാകും.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

· സ്ട്രിംഗ് (സ്ട്രിംഗ്) -- അയയ്ക്കുന്ന ഡാറ്റ.

റിട്ടേൺസ്
പകർത്തിയ ബൈറ്റുകളുടെ അളവ് അല്ലെങ്കിൽ -1 അടങ്ങുന്ന ഒരു പൂർണ്ണസംഖ്യ.

Channel.append(ചാനൽ, സ്ട്രിംഗ്)
ഈ ഫംഗ്ഷൻ ബഫറിന്റെ ഉള്ളടക്കത്തിലേക്ക് സ്ട്രിംഗ് ആർഗ്യുമെന്റ് കൂട്ടിച്ചേർക്കുന്നു. ചടങ്ങ്
പകർത്തിയ ദൈർഘ്യം നൽകുന്നു, അല്ലെങ്കിൽ, അത് -1 നൽകുന്നു.

ഈ ഫംഗ്‌ഷനുള്ള ഡാറ്റ സെറ്റ് അയയ്‌ക്കില്ല. അവർ HAProxy യുടെ അവസാനത്തിനായി കാത്തിരിക്കുന്നു
പ്രോസസ്സ് ചെയ്യുന്നു, അതിനാൽ ബഫർ പൂർണ്ണമാകും.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

· സ്ട്രിംഗ് (സ്ട്രിംഗ്) -- അയയ്ക്കുന്ന ഡാറ്റ.

റിട്ടേൺസ്
പകർത്തിയ ബൈറ്റുകളുടെ അളവ് അല്ലെങ്കിൽ -1 അടങ്ങുന്ന ഒരു പൂർണ്ണസംഖ്യ.

Channel.send(ചാനൽ, സ്ട്രിംഗ്)
ഈ ഫംഗ്‌ഷന് ഡാറ്റ ഉടനടി അയയ്‌ക്കേണ്ടതുണ്ട്. കണക്ഷൻ ആണെങ്കിൽ ഒഴികെ
അടയ്ക്കുക, ബഫർ പതിവായി ഫ്ലഷ് ചെയ്യപ്പെടുകയും എല്ലാ സ്ട്രിംഗും അയയ്ക്കുകയും ചെയ്യാം.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

· സ്ട്രിംഗ് (സ്ട്രിംഗ്) -- അയയ്ക്കുന്ന ഡാറ്റ.

റിട്ടേൺസ്
പകർത്തിയ ബൈറ്റുകളുടെ അളവ് അല്ലെങ്കിൽ -1 അടങ്ങുന്ന ഒരു പൂർണ്ണസംഖ്യ.

Channel.get_in_length(ചാനൽ)
ഈ ഫംഗ്‌ഷൻ ബഫറിന്റെ ഇൻപുട്ട് ഭാഗത്തിന്റെ ദൈർഘ്യം നൽകുന്നു.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

റിട്ടേൺസ്
ലഭ്യമായ ബൈറ്റുകളുടെ അളവ് അടങ്ങുന്ന ഒരു പൂർണ്ണസംഖ്യ.

Channel.get_out_length(ചാനൽ)
ഈ ഫംഗ്‌ഷൻ ബഫറിന്റെ ഔട്ട്‌പുട്ട് ഭാഗത്തിന്റെ ദൈർഘ്യം നൽകുന്നു.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

റിട്ടേൺസ്
ലഭ്യമായ ബൈറ്റുകളുടെ അളവ് അടങ്ങുന്ന ഒരു പൂർണ്ണസംഖ്യ.

Channel.forward(ചാനൽ, int)
ഈ ഫംഗ്‌ഷൻ ബഫറിന്റെ ഇൻപുട്ട് ഭാഗത്ത് നിന്ന് ഔട്ട്‌പുട്ട് ഭാഗത്തേക്ക് ബൈറ്റുകൾ കൈമാറുന്നു.

വാദങ്ങൾ

· ചാനൽ (ക്ലാസ്_ചാനൽ) -- കൃത്രിമമായ ചാനൽ.

· int (പൂർണ്ണസംഖ്യ) -- ഫോർവേഡ് ചെയ്യപ്പെടുന്ന ഡാറ്റയുടെ അളവ്.

ക്ലാസ് HTTP()
ഈ ക്ലാസിൽ എല്ലാ HTTP കൃത്രിമത്വ പ്രവർത്തനങ്ങളും അടങ്ങിയിരിക്കുന്നു.

HTTP.req_get_headers(http)
എല്ലാ അഭ്യർത്ഥന തലക്കെട്ടുകളും അടങ്ങുന്ന ഒരു അറേ നൽകുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

റിട്ടേൺസ്
തലക്കെട്ടുകളുടെ നിര.

കാണുക HTTP.res_get_headers()

മടങ്ങിയ അറേയുടെ രൂപമാണിത്:

HTTP:req_get_headers()[' '][ ] = " "

പ്രാദേശിക hdr = HTTP:req_get_headers()
hdr["host"][0] = "www.test.com"
hdr["അംഗീകരിക്കുക"][0] = "ഓഡിയോ/അടിസ്ഥാന q=1"
hdr["അംഗീകരിക്കുക"][1] = "ഓഡിയോ/*, q=0.2"
hdr["അംഗീകരിക്കുക"][2] = "*/*, q=0.1"

HTTP.res_get_headers(http)
എല്ലാ പ്രതികരണ തലക്കെട്ടുകളും അടങ്ങുന്ന ഒരു അറേ നൽകുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

റിട്ടേൺസ്
തലക്കെട്ടുകളുടെ നിര.

കാണുക HTTP.req_get_headers()

മടങ്ങിയ അറേയുടെ രൂപമാണിത്:

HTTP:res_get_headers()[' '][ ] = " "

പ്രാദേശിക hdr = HTTP:req_get_headers()
hdr["host"][0] = "www.test.com"
hdr["അംഗീകരിക്കുക"][0] = "ഓഡിയോ/അടിസ്ഥാന q=1"
hdr["അംഗീകരിക്കുക"][1] = "ഓഡിയോ/*, q=0.2"
hdr["അംഗീകരിക്കുക"][2] = "*.*, q=0.1"

HTTP.req_add_header(http, പേര്, മൂല്യം)
അഭ്യർത്ഥനയിൽ ഒരു HTTP തലക്കെട്ട് ഫീൽഡ് കൂട്ടിച്ചേർക്കുന്നു, അതിന്റെ പേര് "പേര്" എന്നതിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്
ആരുടെ മൂല്യം "മൂല്യം" എന്നതിൽ നിർവചിച്ചിരിക്കുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

· മൂല്യം (സ്ട്രിംഗ്) -- തലക്കെട്ട് മൂല്യം.

കാണുക HTTP.res_add_header()

HTTP.res_add_header(http, പേര്, മൂല്യം)
പ്രതികരണത്തിൽ ഒരു HTTP ഹെഡർ ഫീൽഡ് കൂട്ടിച്ചേർക്കുന്നു, അതിന്റെ പേര് "പേര്" എന്നതിൽ വ്യക്തമാക്കിയിരിക്കുന്നു
ആരുടെ മൂല്യം "മൂല്യം" എന്നതിൽ നിർവചിച്ചിരിക്കുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

· മൂല്യം (സ്ട്രിംഗ്) -- തലക്കെട്ട് മൂല്യം.

കാണുക HTTP.req_add_header()

HTTP.req_del_header(http, പേര്)
അഭ്യർത്ഥനയിലെ എല്ലാ HTTP ഹെഡർ ഫീൽഡുകളും നീക്കം ചെയ്യുന്നു, അതിന്റെ പേര് "പേരിൽ" വ്യക്തമാക്കിയിരിക്കുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

കാണുക HTTP.res_del_header()

HTTP.res_del_header(http, പേര്)
പ്രതികരണത്തിലെ എല്ലാ HTTP ഹെഡർ ഫീൽഡുകളും നീക്കംചെയ്യുന്നു, അതിന്റെ പേര് "പേരിൽ" വ്യക്തമാക്കിയിരിക്കുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

കാണുക HTTP.req_del_header()

HTTP.req_set_header(http, പേര്, മൂല്യം)
ഈ വേരിയബിൾ "പേര്" എന്ന തലക്കെട്ടിന്റെ എല്ലാ സംഭവങ്ങളെയും മാറ്റിസ്ഥാപിക്കുന്നു, അതിൽ ഒന്ന് മാത്രം അടങ്ങിയിരിക്കുന്നു
മൂല്യം".

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

· മൂല്യം (സ്ട്രിംഗ്) -- തലക്കെട്ട് മൂല്യം.

കാണുക HTTP.res_set_header()

ഈ ഫംഗ്‌ഷൻ ഇനിപ്പറയുന്ന കോഡിന്റെ അതേ വർക്ക് ചെയ്യുന്നു:

ഫംഗ്‌ഷൻ fcn(txn)
TXN.http:req_del_header("തലക്കെട്ട്")
TXN.http:req_add_header("തലക്കെട്ട്", "മൂല്യം")
അവസാനിക്കുന്നു

HTTP.res_set_header(http, പേര്, മൂല്യം)
ഈ വേരിയബിൾ "പേര്" എന്ന തലക്കെട്ടിന്റെ എല്ലാ സംഭവങ്ങളെയും മാറ്റിസ്ഥാപിക്കുന്നു, അതിൽ ഒന്ന് മാത്രം അടങ്ങിയിരിക്കുന്നു
മൂല്യം".

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

· മൂല്യം (സ്ട്രിംഗ്) -- തലക്കെട്ട് മൂല്യം.

കാണുക HTTP.req_rep_header()

HTTP.req_rep_header(http, പേര്, റീജക്സ്, മാറ്റിസ്ഥാപിക്കുക)
"പേര്" എന്ന തലക്കെട്ട് ഫീൽഡിന്റെ എല്ലാ സംഭവങ്ങളിലും റെഗുലർ എക്സ്പ്രഷനുമായി പൊരുത്തപ്പെടുന്നു
"regex" ലേയ്ക്ക്, അവയെ "replace" ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. മാറ്റിസ്ഥാപിക്കൽ മൂല്യം
1, 2, പോലെയുള്ള ബാക്ക് റഫറൻസുകൾ അടങ്ങിയിരിക്കാം... ഈ ഫംഗ്‌ഷൻ അഭ്യർത്ഥനയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

· regex (സ്ട്രിംഗ്) -- പൊരുത്തം റെഗുലർ എക്സ്പ്രഷൻ.

· മാറ്റിസ്ഥാപിക്കാൻ (സ്ട്രിംഗ്) -- മാറ്റിസ്ഥാപിക്കൽ മൂല്യം.

കാണുക HTTP.res_rep_header()

HTTP.res_rep_header(http, പേര്, റീജക്സ്, സ്ട്രിംഗ്)
"പേര്" എന്ന തലക്കെട്ട് ഫീൽഡിന്റെ എല്ലാ സംഭവങ്ങളിലും റെഗുലർ എക്സ്പ്രഷനുമായി പൊരുത്തപ്പെടുന്നു
"regex" ലേയ്ക്ക്, അവയെ "replace" ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. മാറ്റിസ്ഥാപിക്കൽ മൂല്യം
1, 2, പോലെയുള്ള ബാക്ക് റഫറൻസുകൾ അടങ്ങിയിരിക്കാം... ഈ ഫംഗ്‌ഷൻ അഭ്യർത്ഥനയ്‌ക്കൊപ്പം പ്രവർത്തിക്കുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

· regex (സ്ട്രിംഗ്) -- പൊരുത്തം റെഗുലർ എക്സ്പ്രഷൻ.

· മാറ്റിസ്ഥാപിക്കാൻ (സ്ട്രിംഗ്) -- മാറ്റിസ്ഥാപിക്കൽ മൂല്യം.

കാണുക HTTP.req_replace_header()

HTTP.req_replace_value(http, പേര്, റീജക്സ്, മാറ്റിസ്ഥാപിക്കുക)
"HTTP.req_replace_header()" പോലെ പ്രവർത്തിക്കുന്നു, അത് റിജക്‌സുമായി പൊരുത്തപ്പെടുന്നു എന്നതൊഴിച്ചാൽ
ഹെഡർ ഫീൽഡിന്റെ "പേര്" എന്നതിന്റെ മുഴുവൻ കോമ-ഡീലിമിറ്റഡ് മൂല്യവും
ശീർഷകം.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

· regex (സ്ട്രിംഗ്) -- പൊരുത്തം റെഗുലർ എക്സ്പ്രഷൻ.

· മാറ്റിസ്ഥാപിക്കാൻ (സ്ട്രിംഗ്) -- മാറ്റിസ്ഥാപിക്കൽ മൂല്യം.

കാണുക HTTP.req_replace_header()

കാണുക HTTP.res_replace_value()

HTTP.res_replace_value(http, പേര്, റീജക്സ്, മാറ്റിസ്ഥാപിക്കുക)
"HTTP.res_replace_header()" പോലെ പ്രവർത്തിക്കുന്നു, അത് റിജക്‌സുമായി പൊരുത്തപ്പെടുന്നു എന്നതൊഴിച്ചാൽ
ഹെഡർ ഫീൽഡിന്റെ "പേര്" എന്നതിന്റെ മുഴുവൻ കോമ-ഡീലിമിറ്റഡ് മൂല്യവും
ശീർഷകം.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്.

· regex (സ്ട്രിംഗ്) -- പൊരുത്തം റെഗുലർ എക്സ്പ്രഷൻ.

· മാറ്റിസ്ഥാപിക്കാൻ (സ്ട്രിംഗ്) -- മാറ്റിസ്ഥാപിക്കൽ മൂല്യം.

കാണുക HTTP.res_replace_header()

കാണുക HTTP.req_replace_value()

HTTP.req_set_method(http, രീതി)
"രീതി" എന്ന പാരാമീറ്റർ ഉപയോഗിച്ച് അഭ്യർത്ഥന രീതി വീണ്ടും എഴുതുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· രീതി (സ്ട്രിംഗ്) -- പുതിയ രീതി.

HTTP.req_set_path(http, പാത)
"പാത്ത്" പാരാമീറ്റർ ഉപയോഗിച്ച് അഭ്യർത്ഥന പാത വീണ്ടും എഴുതുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പാത (സ്ട്രിംഗ്) -- പുതിയ പാത.

HTTP.req_set_query(http, ചോദ്യം)
ആദ്യ ചോദ്യചിഹ്നത്തിന് ശേഷം ദൃശ്യമാകുന്ന അഭ്യർത്ഥനയുടെ അന്വേഷണ സ്ട്രിംഗ് വീണ്ടും എഴുതുന്നു
("?") "ക്വറി" എന്ന പരാമീറ്റർ ഉപയോഗിച്ച്.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· അന്വേഷണം (സ്ട്രിംഗ്) -- പുതിയ ചോദ്യം.

HTTP.req_set_uri(http, ഉറി)
"uri" എന്ന പാരാമീറ്റർ ഉപയോഗിച്ച് അഭ്യർത്ഥന URI വീണ്ടും എഴുതുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· URI (സ്ട്രിംഗ്) -- പുതിയ ഉറി.

HTTP.res_set_status(http, പദവി)
"കോഡ്" എന്ന പാരാമീറ്റർ ഉപയോഗിച്ച് പ്രതികരണ സ്റ്റാറ്റസ് കോഡ് വീണ്ടും എഴുതുന്നു. കാരണം ശ്രദ്ധിക്കുക
പുതിയ കോഡിലേക്ക് സ്വയമേവ പൊരുത്തപ്പെടുന്നു.

വാദങ്ങൾ

· http: (ക്ലാസ്_http) -- ബന്ധപ്പെട്ട http ഒബ്ജക്റ്റ്.

· പദവി (പൂർണ്ണസംഖ്യ) -- പുതിയ പ്രതികരണ സ്റ്റാറ്റസ് കോഡ്.

ക്ലാസ് TXN()
http അല്ലെങ്കിൽ tcp ഇടപാടുമായി ബന്ധപ്പെട്ട എല്ലാ പ്രവർത്തനങ്ങളും txn ക്ലാസിൽ അടങ്ങിയിരിക്കുന്നു
(ടിസിപി സ്ട്രീമിനെക്കാൾ ശ്രദ്ധിക്കുക, ടിസിപി ഇടപാടിന് തുല്യമാണ്, എന്നാൽ എച്ച്ടിടിപി ഇടപാട്
ഒരു tcp സ്ട്രീമിന് സമാനമല്ല).

അഭ്യർത്ഥനകളിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കാനും അതിൽ മാറ്റം വരുത്താനും ഈ ക്ലാസിന്റെ ഉപയോഗം അനുവദിക്കുന്നു
അത് കൈമാറുക.

ഈ ക്ലാസ് നൽകുന്ന എല്ലാ ഫംഗ്‌ഷനുകളും സന്ദർഭത്തിൽ ലഭ്യമാണ്
സാമ്പിൾ-പിടുത്തങ്ങൾ ഒപ്പം ഓഹരി.

TXN.c

റിട്ടേൺസ്
An പരിവർത്തനങ്ങൾ ക്ലാസ്.

ഈ ആട്രിബ്യൂട്ടിൽ കൺവെർട്ടേഴ്സ് ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു.

TXN.sc

റിട്ടേൺസ്
An പരിവർത്തനങ്ങൾ ക്ലാസ്.

ഈ ആട്രിബ്യൂട്ടിൽ കൺവെർട്ടേഴ്സ് ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു. ഈ വസ്തുവിന്റെ പ്രവർത്തനങ്ങൾ
എല്ലായ്പ്പോഴും ഒരു സ്ട്രിംഗ് നൽകുന്നു.

TXN.f

റിട്ടേൺസ്
An ലഭ്യമാക്കുന്നു ക്ലാസ്.

ഈ ആട്രിബ്യൂട്ടിൽ ഒരു Fetches ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു.

TXN.sf

റിട്ടേൺസ്
An ലഭ്യമാക്കുന്നു ക്ലാസ്.

ഈ ആട്രിബ്യൂട്ടിൽ ഒരു Fetches ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു. ഈ വസ്തുവിന്റെ പ്രവർത്തനങ്ങൾ
എല്ലായ്പ്പോഴും ഒരു സ്ട്രിംഗ് നൽകുന്നു.

TXN.req

റിട്ടേൺസ്
An ചാനൽ ക്ലാസ്.

ഈ ആട്രിബ്യൂട്ടിൽ അഭ്യർത്ഥന ബഫറിനായി ഒരു ചാനൽ ക്ലാസ് ഒബ്‌ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു.

TXN.res

റിട്ടേൺസ്
An ചാനൽ ക്ലാസ്.

ഈ ആട്രിബ്യൂട്ടിൽ പ്രതികരണ ബഫറിനായുള്ള ഒരു ചാനൽ ക്ലാസ് ഒബ്‌ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു.

TXN.http

റിട്ടേൺസ്
An HTTP ക്ലാസ്.

ഈ ആട്രിബ്യൂട്ടിൽ ഒരു HTTP ക്ലാസ് ഒബ്‌ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു. പ്രോക്സി ഉണ്ടെങ്കിൽ മാത്രമേ ഇത് ലഭ്യമാകൂ
"മോഡ് http" പ്രവർത്തനക്ഷമമാക്കി.

TXN.log(TXN, ലോഗ് ലെവൽ, സന്ദേശം)
ഈ പ്രവർത്തനം ഒരു ലോഗ് അയയ്ക്കുന്നു. HAProxy അനുസരിച്ച് ലോഗ് അയച്ചു
കോൺഫിഗറേഷൻ ഫയൽ, അത് കോൺഫിഗർ ചെയ്തിട്ടുണ്ടെങ്കിൽ സ്ഥിരസ്ഥിതി syslog സെർവറിൽ
അത് അനുവദനീയമാണെങ്കിൽ stderr.

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· ലോഗ് ലെവൽ (പൂർണ്ണസംഖ്യ) -- ലോഗ് ലെവൽ സന്ദേശവുമായി ബന്ധപ്പെട്ടതാണോ. ഇത് എ
0 നും 7 നും ഇടയിലുള്ള സംഖ്യ.

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക core.emerg, core.alert, core.crit, core.err, core.warning, core.notice,
core.info, core.debug (ലോഗ് ലെവൽ നിർവചനങ്ങൾ)

കാണുക TXN.deflog

കാണുക TXN.ഡീബഗ്

കാണുക TXN.Info

കാണുക TXN. മുന്നറിയിപ്പ്

കാണുക TXN.അലേർട്ട്

TXN.deflog(TXN, സന്ദേശം)
എന്നതുമായി ബന്ധപ്പെട്ടിരിക്കുന്ന പ്രോക്സിക്കായി ഡിഫോൾട്ട് ലോഗ്‌ലെവൽ ഉള്ള ഒരു ലോഗ് ലൈൻ അയയ്ക്കുന്നു
ഇടപാട്.

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക TXN.log

TXN.ഡീബഗ്(txn, സന്ദേശം)

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക TXN.log

ഇനിപ്പറയുന്നതിനേക്കാൾ ഒരേ ജോലി ചെയ്യുന്നു:

ഫംഗ്‌ഷൻ ഡീബഗ് (txn, msg)
TXN.log(txn, core.debug, msg)
അവസാനിക്കുന്നു

TXN.Info(txn, സന്ദേശം)

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക TXN.log

ഫംഗ്‌ഷൻ ഡീബഗ് (txn, msg)
TXN.log(txn, core.info, msg)
അവസാനിക്കുന്നു

TXN.മുന്നറിയിപ്പ്(txn, സന്ദേശം)

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക TXN.log

ഫംഗ്‌ഷൻ ഡീബഗ് (txn, msg)
TXN.log(txn, core.warning, msg)
അവസാനിക്കുന്നു

TXN.Alert(txn, സന്ദേശം)

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· msg (സ്ട്രിംഗ്) -- ലോഗ് ഉള്ളടക്കം.

കാണുക TXN.log

ഫംഗ്‌ഷൻ ഡീബഗ് (txn, msg)
TXN.log(txn, core.alert, msg)
അവസാനിക്കുന്നു

TXN.get_priv(txn)
നിലവിലെ ഇടപാടിൽ സംഭരിച്ചിരിക്കുന്ന Lua ഡാറ്റ തിരികെ നൽകുക (കൂടെ TXN.set_priv())
പ്രവർത്തനം. ഡാറ്റ സംഭരിച്ചില്ലെങ്കിൽ, അത് ഒരു പൂജ്യ മൂല്യം നൽകുന്നു.

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

റിട്ടേൺസ്
മുമ്പ് സംഭരിച്ച അതാര്യമായ ഡാറ്റ, അല്ലെങ്കിൽ ഒന്നും ലഭ്യമല്ലെങ്കിൽ ഇല്ല.

TXN.set_priv(txn, ഡാറ്റ)
നിലവിലെ HAProxy ഇടപാടിൽ ഏതെങ്കിലും ഡാറ്റ സംഭരിക്കുക. ഈ പ്രവർത്തനം പഴയതിന് പകരമാണ്
സംഭരിച്ച ഡാറ്റ.

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· ഡാറ്റ (അതാര്യമാണ്) -- ഇടപാടിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റ.

TXN.set_var(TXN, ഇതുണ്ട്, മൂല്യം)
ഒരു ലുവാ തരം HAProxy തരത്തിൽ പരിവർത്തനം ചെയ്യുകയും ഒരു വേരിയബിളിൽ സംഭരിക്കുകയും ചെയ്യുന്നു .

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· വേരിയബിൾ (സ്ട്രിംഗ്) -- HAProxy വേരിയബിളിനൊപ്പം വേരിയബിൾ നാമം
വാക്യഘടന.

· മൂല്യം (അതാര്യമാണ്) -- വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റ.

TXN.get_var(TXN, var)
ലുവാ തരത്തിൽ വേരിയബിൾ കൺവെർട്ടറിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റ നൽകുന്നു .

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· വേരിയബിൾ (സ്ട്രിംഗ്) -- HAProxy വേരിയബിളിനൊപ്പം വേരിയബിൾ നാമം
വാക്യഘടന.

TXN.get_headers(txn)
ഈ ഫംഗ്‌ഷൻ തലക്കെട്ടുകളുടെ ഒരു നിര നൽകുന്നു.

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

റിട്ടേൺസ്
തലക്കെട്ടുകളുടെ ഒരു നിര.

TXN.done(txn)
ഈ ഫംഗ്‌ഷൻ ഇടപാടിന്റെയും അനുബന്ധ സെഷന്റെയും പ്രോസസ്സിംഗ് അവസാനിപ്പിക്കുന്നു.
ഒരു നിർണായക പിശക് കണ്ടെത്തുമ്പോൾ അല്ലെങ്കിൽ പ്രോസസ്സിംഗ് അവസാനിപ്പിക്കാൻ ഇത് ഉപയോഗിക്കാം
ചില ഡാറ്റ ക്ലയന്റിലേക്ക് തിരികെ നൽകി (ഉദാ: ഒരു റീഡയറക്‌ട്).

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

TXN.set_loglevel(txn, ലോഗ് ലെവൽ)
നിലവിലെ അഭ്യർത്ഥനയുടെ ലോഗ് ലെവൽ മാറ്റാൻ ഉപയോഗിക്കുന്നു. "ലോഗ് ലെവൽ" ഒരു ആയിരിക്കണം
0 നും 7 നും ഇടയിലുള്ള പൂർണ്ണസംഖ്യ.

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· ലോഗ് ലെവൽ (പൂർണ്ണസംഖ്യ) -- ആവശ്യമായ ലോഗ് ലെവൽ. ഈ വേരിയബിൾ ഒന്നാകാം

കാണുക കാമ്പ്.

TXN.set_tos(txn, ടോസ്)
എന്നതിലേക്ക് ക്ലയന്റിലേക്ക് അയച്ച പാക്കറ്റുകളുടെ TOS അല്ലെങ്കിൽ DSCP ഫീൽഡ് മൂല്യം സജ്ജീകരിക്കാൻ ഉപയോഗിക്കുന്നു
ഇതിനെ പിന്തുണയ്ക്കുന്ന പ്ലാറ്റ്‌ഫോമുകളിൽ "ടോസ്" എന്നതിൽ മൂല്യം കടന്നുപോയി.

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· ടോൾസ് (പൂർണ്ണസംഖ്യ) -- പുതിയ TOS os DSCP.

TXN.set_mark(txn, അടയാളം)
ക്ലയന്റിലേക്ക് മൂല്യത്തിലേക്ക് അയച്ച എല്ലാ പാക്കറ്റുകളിലും നെറ്റ്ഫിൽറ്റർ മാർക്ക് സജ്ജീകരിക്കാൻ ഉപയോഗിക്കുന്നു
അതിനെ പിന്തുണയ്ക്കുന്ന പ്ലാറ്റ്ഫോമുകളിൽ "മാർക്ക്" കടന്നു.

വാദങ്ങൾ

· txn (class_txn) -- ഡാറ്റ അടങ്ങുന്ന ക്ലാസ് txn ഒബ്ജക്റ്റ്.

· അടയാളം (പൂർണ്ണസംഖ്യ) -- മാർക്ക് മൂല്യം.

ക്ലാസ് സോക്കറ്റ്()
ഈ ക്ലാസ് ലുവാ സോക്കറ്റ് ക്ലാസുമായി പൊരുത്തപ്പെടണം. 'ഉപഭോക്താവ്' മാത്രം
പ്രവർത്തനങ്ങൾ ലഭ്യമാണ്. Lua Socket ഡോക്യുമെന്റേഷൻ കാണുക:

http://w3.impa.br/~diego/software/luasocket/tcp.html

Socket.close(സോക്കറ്റ്)
ഒരു TCP ഒബ്‌ജക്‌റ്റ് അടയ്‌ക്കുന്നു. ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്ന ആന്തരിക സോക്കറ്റ് അടച്ചിരിക്കുന്നു, ലോക്കൽ
ഒബ്ജക്റ്റ് ബന്ധിപ്പിച്ച വിലാസം മറ്റ് ആപ്ലിക്കേഷനുകൾക്ക് ലഭ്യമാക്കിയിട്ടുണ്ട്. ഇല്ല
തുടർന്നുള്ള പ്രവർത്തനങ്ങൾ (ക്ലോസ് മെത്തേഡിലേക്കുള്ള കൂടുതൽ കോളുകൾ ഒഴികെ) a
അടച്ച സോക്കറ്റ്.

വാദങ്ങൾ

· സോക്കറ്റ് (ക്ലാസ്_സോക്കറ്റ്) -- കൃത്രിമ സോക്കറ്റ് ആണ്.

ശ്രദ്ധിക്കുക: ഉപയോഗിച്ച എല്ലാ സോക്കറ്റുകളും ആവശ്യമില്ലാത്തപ്പോൾ അടച്ചിടേണ്ടത് പ്രധാനമാണ്, കാരണം
പല സിസ്റ്റങ്ങളിലും, ഓരോ സോക്കറ്റും ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ ഉപയോഗിക്കുന്നു, അവ പരിമിതമായ സിസ്റ്റം ആണ്
വിഭവങ്ങൾ. മാലിന്യം ശേഖരിക്കുന്ന വസ്തുക്കൾ നശിപ്പിക്കപ്പെടുന്നതിന് മുമ്പ് സ്വയമേവ അടച്ചിരിക്കും.
എന്നിരുന്നാലും.

Socket.connect(സോക്കറ്റ്, വിലാസം[, തുറമുഖം])
ഒരു സോക്കറ്റ് ഒബ്‌ജക്റ്റ് ഒരു റിമോട്ട് ഹോസ്റ്റിലേക്ക് കണക്റ്റുചെയ്യാനുള്ള ശ്രമങ്ങൾ.

പിശക് സംഭവിച്ചാൽ, മെത്തേഡ് nil നൽകുന്നു, തുടർന്ന് പിശക് വിവരിക്കുന്ന ഒരു സ്ട്രിംഗ്.
വിജയിച്ചാൽ, രീതി 1 നൽകുന്നു.

വാദങ്ങൾ

· സോക്കറ്റ് (ക്ലാസ്_സോക്കറ്റ്) -- കൃത്രിമ സോക്കറ്റ് ആണ്.

· വിലാസം (സ്ട്രിംഗ്) -- ഒരു IP വിലാസമോ ഹോസ്റ്റ് നാമമോ ആകാം. അതിനായി താഴെ കാണുക
കൂടുതൽ വിവരങ്ങൾ.

· തുറമുഖം (പൂർണ്ണസംഖ്യ) -- [1..64K] ശ്രേണിയിലെ ഒരു പൂർണ്ണസംഖ്യയായിരിക്കണം.

റിട്ടേൺസ്
1 അല്ലെങ്കിൽ പൂജ്യം.

ഒരു അഡ്രസ് ഫീൽഡ് എക്സ്റ്റൻഷൻ കണക്ട് ചെയ്യാൻ കണക്ട്() ഫംഗ്ഷൻ ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു
TCP ഒഴികെയുള്ള മറ്റ് സ്ട്രീം. ഒരു simpleipv4 അല്ലെങ്കിൽ ipv6 വിലാസം അടങ്ങിയ വാക്യഘടനയാണ്
അടിസ്ഥാനപരമായി പ്രതീക്ഷിക്കുന്ന ഫോർമാറ്റ്. ഈ ഫോർമാറ്റിന് പോർട്ട് ആവശ്യമാണ്.

"/സോക്കറ്റ്/പാത്ത്" പോലെയുള്ള ഒരു സോക്കറ്റ് പാതയാണ് അംഗീകരിച്ചിട്ടുള്ള മറ്റ് ഫോർമാറ്റ്, ഇത് ബന്ധിപ്പിക്കാൻ അനുവദിക്കുന്നു
ഒരു സോക്കറ്റിലേക്ക്. അബ്‌സ്‌ട്രാക്റ്റ് നെയിംസ്‌പെയ്‌സുകൾ "abns@" എന്ന പ്രിഫിക്‌സിനൊപ്പം പിന്തുണയ്‌ക്കുന്നു, അവസാനം
"fd@" എന്ന പ്രിഫിക്‌സ് ഉപയോഗിച്ച് ഫയൽസ്‌ക്രിയോറ്റർ നൽകാം. പ്രിഫിക്‌സ് "ipv4@", "ipv6@"
"unix@" എന്നിവയും പിന്തുണയ്ക്കുന്നു. പോർട്ട് സ്ട്രിംഗിലൂടെ കടന്നുപോകാം. വാക്യഘടന
"127.0.0.1:1234" സാധുവാണ്. ഈ സാഹചര്യത്തിൽ, പരാമീറ്റർ തുറമുഖം അവഗണിക്കപ്പെടുന്നു.

Socket.connect_ssl(സോക്കറ്റ്, വിലാസം, പോർട്ട്)
ഫംഗ്ഷൻ സോക്കറ്റിനേക്കാൾ സമാന സ്വഭാവം:കണക്റ്റ്, എന്നാൽ SSL ഉപയോഗിക്കുന്നു.

വാദങ്ങൾ

· സോക്കറ്റ് (ക്ലാസ്_സോക്കറ്റ്) -- കൃത്രിമ സോക്കറ്റ് ആണ്.

റിട്ടേൺസ്
1 അല്ലെങ്കിൽ പൂജ്യം.

Socket.getpeername(socket)
കണക്റ്റുചെയ്‌ത ക്ലയന്റ് ഒബ്‌ജക്റ്റിന്റെ വിദൂര വശത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ നൽകുന്നു.

പിയറിന്റെ ഐപി വിലാസത്തോടുകൂടിയ ഒരു സ്‌ട്രിംഗ് നൽകുന്നു, തുടർന്ന് പോർട്ട് നമ്പറും
പിയർ കണക്ഷനുപയോഗിക്കുന്നു. പിശക് സംഭവിച്ചാൽ, രീതി പൂജ്യമായി നൽകും.

വാദങ്ങൾ

· സോക്കറ്റ് (ക്ലാസ്_സോക്കറ്റ്) -- കൃത്രിമ സോക്കറ്റ് ആണ്.

റിട്ടേൺസ്
സെർവർ വിവരങ്ങൾ അടങ്ങുന്ന ഒരു സ്ട്രിംഗ്.

Socket.getsockname(സോക്കറ്റ്)
വസ്തുവുമായി ബന്ധപ്പെട്ട പ്രാദേശിക വിലാസ വിവരങ്ങൾ നൽകുന്നു.

ലോക്കൽ ഐപി വിലാസമുള്ള ഒരു സ്‌ട്രിംഗും പോർട്ടിനൊപ്പം ഒരു നമ്പറും ഈ രീതി നൽകുന്നു. ഇൻ
പിശക് സംഭവിച്ചാൽ, രീതി പൂജ്യമായി നൽകുന്നു.

വാദങ്ങൾ

· സോക്കറ്റ് (ക്ലാസ്_സോക്കറ്റ്) -- കൃത്രിമ സോക്കറ്റ് ആണ്.

റിട്ടേൺസ്
ക്ലയന്റ് വിവരങ്ങൾ അടങ്ങുന്ന ഒരു സ്ട്രിംഗ്.

Socket.receive(സോക്കറ്റ്[, മാതൃക[, ഉപസർഗ്ഗം]])
നിർദ്ദിഷ്ട റീഡ് പാറ്റേൺ അനുസരിച്ച് ഒരു ക്ലയന്റ് ഒബ്‌ജക്റ്റിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുന്നു. പാറ്റേണുകൾ
Lua ഫയൽ I/O ഫോർമാറ്റും എല്ലാം തമ്മിലുള്ള പ്രകടനത്തിലെ വ്യത്യാസവും പിന്തുടരുക
പാറ്റേണുകൾ നിസ്സാരമാണ്.

വാദങ്ങൾ

· സോക്കറ്റ് (ക്ലാസ്_സോക്കറ്റ്) -- കൃത്രിമ സോക്കറ്റ് ആണ്.

· പാറ്റേൺ (സ്ട്രിംഗ്|പൂർണ്ണസംഖ്യ) -- എന്താണ് ആവശ്യമുള്ളതെന്ന് വിവരിക്കുക (ചുവടെ കാണുക).

· പ്രിഫിക്‌സ് (സ്ട്രിംഗ്) -- നൽകിയ ഡാറ്റയുടെ പ്രിഫിക്‌സ് ആയ ഒരു സ്ട്രിംഗ്.

റിട്ടേൺസ്
ആവശ്യമായ ഡാറ്റ അടങ്ങിയ ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ nil.

പാറ്റേൺ ഇനിപ്പറയുന്നവയിലേതെങ്കിലും ആകാം:

·

`*a`: വായിക്കുന്നു നിന്ന് The സോക്കറ്റ് വരുവോളം The കണക്ഷൻ is അടച്ചു. ഇല്ല
എൻഡ്-ഓഫ്-ലൈൻ വിവർത്തനം നടത്തുന്നു;

·

`*l`: വായിക്കുന്നു a വര of ടെക്സ്റ്റ് നിന്ന് The സോക്കറ്റ്. ദി വര is അവസാനിപ്പിച്ചു by a
LF പ്രതീകം (ASCII 10), ഓപ്‌ഷണലായി ഒരു CR പ്രതീകത്തിന് മുമ്പായി (ASCII 13).
നൽകിയ വരിയിൽ CR, LF പ്രതീകങ്ങൾ ഉൾപ്പെടുത്തിയിട്ടില്ല. സത്യത്തിൽ,
എല്ലാ CR പ്രതീകങ്ങളും പാറ്റേൺ അവഗണിക്കുന്നു. ഇതാണ് സ്ഥിരസ്ഥിതി പാറ്റേൺ.

·

സംഖ്യ: കാരണങ്ങൾ The രീതി ലേക്ക് വായിക്കുക a വ്യക്തമാക്കിയ അക്കം of ബൈറ്റുകൾ നിന്ന് The
സോക്കറ്റ്. പ്രിഫിക്‌സ് തുടക്കത്തിലേക്ക് സംയോജിപ്പിക്കേണ്ട ഒരു ഓപ്‌ഷണൽ സ്‌ട്രിംഗാണ്
മടങ്ങിവരുന്നതിന് മുമ്പ് ലഭിച്ച ഏതെങ്കിലും ഡാറ്റ.

· ശൂന്യമാണ്: പാറ്റേൺ ശൂന്യമായി വിടുകയാണെങ്കിൽ, സ്ഥിരസ്ഥിതി ഓപ്ഷൻ ഇതാണ് *l.

വിജയകരമാണെങ്കിൽ, ഈ രീതി സ്വീകരിച്ച പാറ്റേൺ നൽകുന്നു. തെറ്റ് സംഭവിച്ചാൽ, ദി
മെത്തേഡ് nil നൽകുന്നു, തുടർന്ന് ഒരു പിശക് സന്ദേശത്തിന് ശേഷം സ്ട്രിംഗ് 'അടച്ചിരിക്കുന്നു'
സംപ്രേഷണം പൂർത്തിയാകുന്നതിന് മുമ്പ് അല്ലെങ്കിൽ സ്ട്രിംഗ് പൂർത്തിയാകുന്നതിന് മുമ്പ് കണക്ഷൻ അവസാനിപ്പിച്ച സാഹചര്യത്തിൽ
ഓപ്പറേഷൻ സമയത്ത് സമയപരിധി ഉണ്ടായാൽ 'കാലാവധി'. കൂടാതെ, പിശകിന് ശേഷം
സന്ദേശം, ഫംഗ്ഷൻ ട്രാൻസ്മിഷന്റെ ഭാഗിക ഫലം നൽകുന്നു.

പ്രധാന കുറിപ്പ്: ഈ ഫംഗ്‌ഷൻ ഗുരുതരമായി മാറ്റി. ഇത് ഒന്നിലധികം പിന്തുണയ്ക്കാൻ ഉപയോഗിച്ചു
പാറ്റേണുകൾ (പക്ഷേ ഈ സവിശേഷത ഉപയോഗിച്ചതായി ഞാൻ ഒരിക്കലും കണ്ടിട്ടില്ല) ഇപ്പോൾ അത് ഇല്ല.
വിജയകരമായ ഫലങ്ങൾ പോലെ തന്നെ ഭാഗിക ഫലങ്ങൾ നൽകാറുണ്ടായിരുന്നു. ഈ
അവസാനത്തെ ഫീച്ചർ എല്ലാ ഫംഗ്‌ഷനുകളും പിശകിനാൽ തിരികെ നൽകണമെന്ന ആശയം ലംഘിച്ചു. അങ്ങനെ
അതും മാറ്റി.

Socket.send(സോക്കറ്റ്, ഡാറ്റ[, ആരംഭിക്കുക[, അവസാനിക്കുന്നു]])
ക്ലയന്റ് ഒബ്ജക്റ്റ് വഴി ഡാറ്റ അയയ്ക്കുന്നു.

വാദങ്ങൾ

· സോക്കറ്റ് (ക്ലാസ്_സോക്കറ്റ്) -- കൃത്രിമ സോക്കറ്റ് ആണ്.

· ഡാറ്റ (സ്ട്രിംഗ്) -- അയയ്‌ക്കുന്ന ഡാറ്റ.

· തുടക്കം (പൂർണ്ണസംഖ്യ) -- ഡാറ്റയുടെ ബഫറിലെ ആരംഭ സ്ഥാനം
അയക്കണം.

· അവസാനിക്കുന്നു (പൂർണ്ണസംഖ്യ) -- ഡാറ്റയുടെ ബഫറിലെ അവസാന സ്ഥാനം
അയച്ചു.

റിട്ടേൺസ്
താഴെ നോക്കുക.

അയയ്‌ക്കേണ്ട സ്‌ട്രിംഗ് ആണ് ഡാറ്റ. ഐ, ജെ എന്നീ ഓപ്ഷണൽ ആർഗ്യുമെന്റുകൾ കൃത്യമായി പ്രവർത്തിക്കുന്നു
ഒരു സബ്‌സ്‌ട്രിംഗിന്റെ തിരഞ്ഞെടുപ്പ് അയയ്‌ക്കാൻ അനുവദിക്കുന്നതിനുള്ള സ്റ്റാൻഡേർഡ് string.sub Lua ഫംഗ്‌ഷൻ.

വിജയകരമാണെങ്കിൽ, [ആരംഭം, അവസാനം] ഉള്ളിലെ അവസാന ബൈറ്റിന്റെ സൂചിക ഈ രീതി നൽകുന്നു
അത് അയച്ചിട്ടുണ്ട്. ആരംഭം 1 ആണെങ്കിൽ അല്ലെങ്കിൽ ഇല്ലെങ്കിൽ, ഇത് ഫലപ്രദമായി ആണ്
അയച്ച ബൈറ്റുകളുടെ ആകെ എണ്ണം. പിശക് സംഭവിച്ചാൽ, രീതി പൂജ്യമായി നൽകുന്നു, തുടർന്ന്
ഒരു പിശക് സന്ദേശം, തുടർന്ന് [ആരംഭം, അവസാനം] അതിനുള്ളിലെ അവസാന ബൈറ്റിന്റെ സൂചിക
അയച്ചിട്ടുണ്ട്. അത് പിന്തുടരുന്ന ബൈറ്റിൽ നിന്ന് വീണ്ടും ശ്രമിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. പിശക്
പ്രക്ഷേപണത്തിന് മുമ്പ് കണക്ഷൻ ക്ലോസ് ചെയ്തിട്ടുണ്ടെങ്കിൽ സന്ദേശം 'ക്ലോസ്' ചെയ്യാം
പൂർത്തീകരിച്ചു അല്ലെങ്കിൽ ഈ സമയത്ത് സമയപരിധി ഉണ്ടായാൽ സ്ട്രിംഗ് 'ടൈംഔട്ട്'
ഓപ്പറേഷൻ.

ശ്രദ്ധിക്കുക: ഔട്ട്പുട്ട് ബഫർ ചെയ്തിട്ടില്ല. ചെറിയ സ്ട്രിംഗുകൾക്ക്, എല്ലായ്പ്പോഴും കൂട്ടിച്ചേർക്കുന്നതാണ് നല്ലത്
അവ ലുവായിൽ ('..' ഓപ്പറേറ്ററിനൊപ്പം) പകരം ഒരു കോളിൽ ഫലം അയയ്ക്കുക
രീതി പല തവണ വിളിക്കുന്നു.

Socket.setoption(സോക്കറ്റ്, ഓപ്ഷൻ[, മൂല്യം])
അനുയോജ്യതയ്‌ക്കായി നടപ്പിലാക്കിയതാണ്, ഈ കാൾ ഒന്നും ചെയ്യുന്നില്ല.

Socket.settimeout(സോക്കറ്റ്, മൂല്യം[, മോഡ്])
ഒബ്‌ജക്റ്റിന്റെ കാലഹരണപ്പെട്ട മൂല്യങ്ങൾ മാറ്റുന്നു. എല്ലാ I/O പ്രവർത്തനങ്ങളും തടയുന്നു. അത്
അയയ്‌ക്കുന്ന, സ്വീകരിക്കുന്ന, സ്വീകരിക്കുന്ന രീതികളിലേക്കുള്ള ഏത് കോളും അനിശ്ചിതമായി തടയും,
ഓപ്പറേഷൻ പൂർത്തിയാകുന്നതുവരെ. സെറ്റ് ടൈംഔട്ട് രീതി തുകയുടെ പരിധി നിർവചിക്കുന്നു
I/O രീതികൾ തടയാൻ കഴിയുന്ന സമയം. ഒരു സമയപരിധി കഴിഞ്ഞാൽ, ബാധിച്ചു
ഒരു പിശക് കോഡ് ഉപയോഗിച്ച് രീതികൾ ഉപേക്ഷിക്കുകയും പരാജയപ്പെടുകയും ചെയ്യുന്നു.

കാത്തിരിക്കേണ്ട സമയത്തിന്റെ അളവ് സെക്കന്റുകൾക്കുള്ളിൽ മൂല്യ പാരാമീറ്ററായി വ്യക്തമാക്കിയിരിക്കുന്നു.

കാലഹരണപ്പെടൽ മോഡുകൾ ബോട്ട് നടപ്പിലാക്കി, നിഷ്ക്രിയത്വമാണ് ഏകീകരിക്കാവുന്ന സമയപരിധി
ഇന്റേണൽ ബഫർ അയയ്‌ക്കുന്നതിനോ ഡാറ്റ സ്വീകരിക്കുന്നതിനോ കാത്തിരിക്കുന്ന സമയം.

വാദങ്ങൾ

· സോക്കറ്റ് (ക്ലാസ്_സോക്കറ്റ്) -- കൃത്രിമ സോക്കറ്റ് ആണ്.

· മൂല്യം (പൂർണ്ണസംഖ്യ) -- കാലഹരണപ്പെട്ട മൂല്യം.

ക്ലാസ് മാപ്പ്()
HAProxy മാപ്പുകളിൽ കുറച്ച് തിരയാൻ ഈ ക്ലാസ് അനുവദിക്കുന്നു. പ്രഖ്യാപിത മാപ്പുകൾ ആകാം
HAProxy മാനേജ്മെന്റ് സോക്കറ്റ് വഴി റൺടൈമിൽ പരിഷ്ക്കരിച്ചു.

ഡിഫോൾട്ട് = "യുഎസ്എ"

-- മാപ്പ് സൃഷ്‌ടിക്കുകയും ലോഡ് ചെയ്യുകയും ചെയ്യുക
ജിയോ = Map.new("geo.map", Map.ip);

-- ഉപയോക്തൃ രാജ്യം തിരികെ നൽകുന്ന പുതിയ കണ്ടെത്തൽ സൃഷ്ടിക്കുക
core.register_fetches("country", function(txn)
പ്രാദേശിക എസ്ആർസി;
ലോക്കൽ ലോക്ക്;

src = txn.f:fhdr ("x-forwarded-for");
എങ്കിൽ (src == nil) അപ്പോൾ
src = txn.f:src()
എങ്കിൽ (src == nil) അപ്പോൾ
സ്ഥിരസ്ഥിതിയായി മടങ്ങുക;
അവസാനിക്കുന്നു
അവസാനിക്കുന്നു

-- ലുക്ക്അപ്പ് നടത്തുക
ലോക്ക് = ജിയോ: ലുക്ക്അപ്പ് (എസ്ആർസി);

എങ്കിൽ (loc == nil) അപ്പോൾ
സ്ഥിരസ്ഥിതിയായി മടങ്ങുക;
അവസാനിക്കുന്നു

റിട്ടേൺ ലോക്ക്;
അവസാനിക്കുന്നു);

Map.int
HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

Map.ip HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

Map.str
HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

മാപ്പ്.ബെഗ്
HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

Map.sub
HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

Map.dir
HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

Map.dom
HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

Map.end
HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

Map.reg
HAProxy configuration.txt ഫയൽ കാണുക, "ACL-കൾ ഉപയോഗിക്കുകയും സാമ്പിളുകൾ ലഭ്യമാക്കുകയും ചെയ്യുന്നു"
ഈ പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതി മനസ്സിലാക്കാൻ ans ഉപവിഭാഗം "ACL അടിസ്ഥാനങ്ങൾ".

Map.new(ഫയൽ, രീതി)
ഒരു മാപ്പ് സൃഷ്‌ടിക്കുകയും ലോഡ് ചെയ്യുകയും ചെയ്യുന്നു.

വാദങ്ങൾ

· ഫയല് (സ്ട്രിംഗ്) -- മാപ്പ് അടങ്ങുന്ന ഫയലാണോ.

· രീതി (പൂർണ്ണസംഖ്യ) -- മാപ്പ് പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ രീതിയാണ്. ആട്രിബ്യൂട്ടുകൾ കാണുക
മാപ്പ് ക്ലാസിന്റെ.

റിട്ടേൺസ്
ഒരു ക്ലാസ് മാപ്പ് ഒബ്ജക്റ്റ്.

കാണുക മാപ്പ് ആട്രിബ്യൂട്ടുകൾ.

Map.lookup(മാപ്പ്, str)
ഒരു മാപ്പിൽ ഒരു ലുക്ക്അപ്പ് നടത്തുക.

വാദങ്ങൾ

· ഭൂപടം (ക്ലാസ്_മാപ്പ്) -- ക്ലാസ് മാപ്പ് ഒബ്ജക്റ്റ് ആണ്.

· str (സ്ട്രിംഗ്) -- കീ ആയി ഉപയോഗിക്കുന്നത് സ്ട്രിംഗ് ആണ്.

റിട്ടേൺസ്
ഫലം അടങ്ങിയ ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ പൊരുത്തമില്ലെങ്കിൽ.

Map.slookup(മാപ്പ്, str)
ഒരു മാപ്പിൽ ഒരു ലുക്ക്അപ്പ് നടത്തുക.

വാദങ്ങൾ

· ഭൂപടം (ക്ലാസ്_മാപ്പ്) -- ക്ലാസ് മാപ്പ് ഒബ്ജക്റ്റ് ആണ്.

· str (സ്ട്രിംഗ്) -- കീ ആയി ഉപയോഗിക്കുന്നത് സ്ട്രിംഗ് ആണ്.

റിട്ടേൺസ്
ഫലം അടങ്ങിയ ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ പൊരുത്തമില്ലെങ്കിൽ ശൂന്യമായ സ്ട്രിംഗ്.

ക്ലാസ് AppletHTTP()
'http' മോഡ് ആവശ്യമുള്ള ആപ്ലെറ്റുകൾക്കൊപ്പമാണ് ഈ ക്ലാസ് ഉപയോഗിക്കുന്നത്. http ആപ്ലെറ്റിന് കഴിയും
എന്നതിൽ രജിസ്റ്റർ ചെയ്യണം core.register_service() പ്രവർത്തനം. അവ ഉപയോഗിക്കുന്നു
HAProxy-യുടെ പുറകിലുള്ള സെർവർ പോലെ ഒരു http അഭ്യർത്ഥന പ്രോസസ്സ് ചെയ്യുന്നു.

ഇതൊരു ഹലോ വേൾഡ് സാമ്പിൾ കോഡാണ്:

core.register_service("ഹലോ-വേൾഡ്", "http", ഫംഗ്‌ഷൻ(ആപ്‌ലെറ്റ്)
പ്രാദേശിക പ്രതികരണം = "ഹലോ വേൾഡ്!"
ആപ്ലെറ്റ്:സെറ്റ്_സ്റ്റാറ്റസ്(200)
applet:add_header("content-length", string.len(response))
applet:add_header("content-type", "text/plain")
applet:start_response()
applet:അയയ്ക്കുക(പ്രതികരണം)
അവസാനിക്കുന്നു)

AppletHTTP.c

റിട്ടേൺസ്
A പരിവർത്തനങ്ങൾ ക്ലാസ്

ഈ ആട്രിബ്യൂട്ടിൽ കൺവെർട്ടേഴ്സ് ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു.

AppletHTTP.sc

റിട്ടേൺസ്
A പരിവർത്തനങ്ങൾ ക്ലാസ്

ഈ ആട്രിബ്യൂട്ടിൽ കൺവെർട്ടേഴ്സ് ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു. ഈ വസ്തുവിന്റെ പ്രവർത്തനങ്ങൾ
എല്ലായ്പ്പോഴും ഒരു സ്ട്രിംഗ് നൽകുന്നു.

AppletHTTP.f

റിട്ടേൺസ്
A ലഭ്യമാക്കുന്നു ക്ലാസ്

ഈ ആട്രിബ്യൂട്ടിൽ ഒരു Fetches ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു. ആപ്ലെറ്റ് എക്സിക്യൂഷൻ എന്നത് ശ്രദ്ധിക്കുക
സ്ഥലത്തിന് സാധുവായ ഒരു HAProxy കോർ HTTP ഇടപാടിലേക്ക് ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല, അതിനാൽ കുറച്ച് സാമ്പിൾ
HTTP ആശ്രിത മൂല്യങ്ങളുമായി (hdr, പാത്ത്, ...) ബന്ധപ്പെട്ട എഫക്റ്റുകൾ ലഭ്യമല്ല.

AppletHTTP.sf

റിട്ടേൺസ്
A ലഭ്യമാക്കുന്നു ക്ലാസ്

ഈ ആട്രിബ്യൂട്ടിൽ ഒരു Fetches ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു. ഈ വസ്തുവിന്റെ പ്രവർത്തനങ്ങൾ
എല്ലായ്പ്പോഴും ഒരു സ്ട്രിംഗ് നൽകുന്നു. ആപ്‌ലെറ്റ് എക്‌സിക്യൂഷൻ സ്ഥലത്തിന് a-ലേക്ക് ആക്‌സസ് ചെയ്യാൻ കഴിയില്ല എന്നത് ശ്രദ്ധിക്കുക
സാധുവായ HAProxy കോർ HTTP ഇടപാട്, അതിനാൽ HTTP-യുമായി ബന്ധപ്പെട്ട ചില സാമ്പിൾ ഫെക്‌തുകൾ
ആശ്രിത മൂല്യങ്ങൾ (hdr, പാത്ത്, ...) ലഭ്യമല്ല.

AppletHTTP. രീതി

റിട്ടേൺസ്
സ്ട്രിംഗ്

ആട്രിബ്യൂട്ട് രീതി HTTP രീതി അടങ്ങിയ ഒരു സ്ട്രിംഗ് നൽകുന്നു.

AppletHTTP.version

റിട്ടേൺസ്
സ്ട്രിംഗ്

ആട്രിബ്യൂട്ട് പതിപ്പ്, HTTP അഭ്യർത്ഥന പതിപ്പ് അടങ്ങിയ ഒരു സ്ട്രിംഗ് നൽകുന്നു.

AppletHTTP.path

റിട്ടേൺസ്
സ്ട്രിംഗ്

ആട്രിബ്യൂട്ട് പാത്ത് HTTP അഭ്യർത്ഥന പാത്ത് അടങ്ങിയ ഒരു സ്ട്രിംഗ് നൽകുന്നു.

AppletHTTP.qs

റിട്ടേൺസ്
സ്ട്രിംഗ്

qs എന്ന ആട്രിബ്യൂട്ട് HTTP അഭ്യർത്ഥന സ്ട്രിംഗ് അടങ്ങിയ ഒരു സ്ട്രിംഗ് നൽകുന്നു.

AppletHTTP.length

റിട്ടേൺസ്
പൂർണ്ണസംഖ്യ

ആട്രിബ്യൂട്ട് ദൈർഘ്യം HTTP ബോഡി ലെങ്ത് അടങ്ങുന്ന ഒരു പൂർണ്ണസംഖ്യ നൽകുന്നു.

AppletHTTP.headers

റിട്ടേൺസ്
ശ്രേണി

ആട്രിബ്യൂട്ട് ഹെഡറുകൾ HTTP തലക്കെട്ടുകൾ അടങ്ങിയ ഒരു അറേ നൽകുന്നു. തലക്കെട്ട്
പേരുകൾ എപ്പോഴും ചെറിയ അക്ഷരത്തിലാണ്. തലക്കെട്ട് പേര് കൂടുതൽ നേരിടാം പോലെ
ഓരോ അഭ്യർത്ഥനയിലും ഒരിക്കൽ, മൂല്യം ആദ്യ സൂചിക മൂല്യമായി 0 ഉപയോഗിച്ച് സൂചികയിലാക്കിയിരിക്കുന്നു. അറേ
ഈ ഫോം ഉണ്ട്:

AppletHTTP.headers[' '][ ] = " "

AppletHTTP.headers["host"][0] = "www.test.com"
AppletHTTP.headers["അംഗീകരിക്കുക"][0] = "ഓഡിയോ/അടിസ്ഥാന q=1"
AppletHTTP.headers["അംഗീകരിക്കുക"][1] = "ഓഡിയോ/*, q=0.2"
AppletHTTP.headers["അംഗീകരിക്കുക"][2] = "*/*, q=0.1"

AppletHTTP.headers
എല്ലാ അഭ്യർത്ഥന തലക്കെട്ടുകളും അടങ്ങുന്ന ഒരു അറേ അടങ്ങിയിരിക്കുന്നു.

AppletHTTP.set_status(applet, കോഡ്)
ഈ ഫംഗ്‌ഷൻ പ്രതികരണത്തിനായി HTTP സ്റ്റാറ്റസ് കോഡ് സജ്ജമാക്കുന്നു. അനുവദനീയമായ കോഡ് ഇതിൽ നിന്നാണ്
XNUM മുതൽ XNUM വരെ.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_ApletHTTP) -- എ AppletHTTP ക്ലാസ്

· കോഡ് (പൂർണ്ണസംഖ്യ) -- സ്റ്റാറ്റസ് കോഡ് ക്ലയന്റിലേക്ക് മടങ്ങി.

AppletHTTP.add_header(applet, പേര്, മൂല്യം)
ഈ ഫംഗ്‌ഷൻ പ്രതികരണത്തിൽ ഒരു തലക്കെട്ട് ചേർക്കുന്നു. തനിപ്പകർപ്പായ തലക്കെട്ടുകൾ തകർന്നിട്ടില്ല.
പ്രത്യേക തലക്കെട്ട് ഉള്ളടക്ക ദൈർഘ്യം പ്രതികരണ ദൈർഘ്യം നിർണ്ണയിക്കാൻ ഉപയോഗിക്കുന്നു. എങ്കിൽ
നിലവിലില്ല, എ ട്രാൻസ്ഫർ-എൻകോഡിംഗ്: ചങ്ക് സജ്ജീകരിച്ചിരിക്കുന്നു, കൂടാതെ ഫംഗ്ഷനിൽ നിന്നുള്ള എല്ലാ എഴുത്തുകളും
AppletHTTP:send() ഒരു ചങ്ക് ആകുക.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_ApletHTTP) -- എ AppletHTTP ക്ലാസ്

· പേര് (സ്ട്രിംഗ്) -- തലക്കെട്ടിന്റെ പേര്

· മൂല്യം (സ്ട്രിംഗ്) -- തലക്കെട്ട് മൂല്യം

AppletHTTP.start_response(applet)
HTTP എഞ്ചിന് പ്രോസസ്സ് ചെയ്യാനും അയയ്ക്കാനും കഴിയുമെന്ന് ഈ ഫംഗ്ഷൻ സൂചിപ്പിക്കുന്നു
പ്രതികരണ തലക്കെട്ടുകൾ. ഇത് വിളിച്ചതിന് ശേഷം പ്രതികരണത്തിലേക്ക് തലക്കെട്ടുകൾ ചേർക്കാൻ ഞങ്ങൾക്ക് കഴിയില്ല; ഞങ്ങൾ
ഉപയോഗിക്കാൻ കഴിയില്ല AppletHTTP:send() ഫംഗ്ഷൻ എങ്കിൽ AppletHTTP:start_response() അല്ല
വിളിച്ചു.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_ApletHTTP) -- എ AppletHTTP ക്ലാസ്

AppletHTTP.getline(applet)
ഈ ഫംഗ്‌ഷൻ http ബോഡിയിൽ നിന്ന് ഒരു ലൈൻ അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു. ഡാറ്റ എങ്കിൽ
റിട്ടേൺ എന്നതിൽ അവസാനമായി ലഭ്യമായ ഡാറ്റയേക്കാൾ ഒരു അന്തിമ '\n' അടങ്ങിയിട്ടില്ല
സ്ട്രീം അവസാനിക്കുന്നതിന് മുമ്പ്.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_ApletHTTP) -- എ AppletHTTP ക്ലാസ്

റിട്ടേൺസ്
ഒരു ചരട്. സ്ട്രീമിന്റെ അറ്റത്ത് എത്തിയാൽ ചരട് ശൂന്യമായിരിക്കും.

AppletHTTP.receive(applet[, വലിപ്പം])
എച്ച്ടിടിപി ബോഡിയിൽ നിന്നുള്ള ഡാറ്റ, നിർദ്ദിഷ്ട റീഡിന് അനുസരിച്ച് വായിക്കുന്നു വലുപ്പം. ആണെങ്കിൽ വലുപ്പം is
കാണുന്നില്ല, ഫംഗ്ഷൻ സ്ട്രീമിലെ എല്ലാ ഉള്ളടക്കവും അവസാനം വരെ വായിക്കാൻ ശ്രമിക്കുന്നു. എങ്കിൽ
The വലുപ്പം http ബോഡിയെക്കാൾ വലുതാണ്, അത് ലഭ്യമായ ഡാറ്റയുടെ അളവ് നൽകുന്നു.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_ApletHTTP) -- എ AppletHTTP ക്ലാസ്

· വലുപ്പം (പൂർണ്ണസംഖ്യ) -- ആവശ്യമായ വായന വലുപ്പം.

റിട്ടേൺസ്
എല്ലായ്‌പ്പോഴും ഒരു സ്ട്രിംഗ് തിരികെ നൽകുക, കണക്ഷൻ അടച്ചിരിക്കുമ്പോൾ സ്‌ട്രിംഗ് ശൂന്യമായിരിക്കും.

AppletHTTP.send(applet, സന്ദേശം)
സന്ദേശം അയയ്‌ക്കുക msg http അഭ്യർത്ഥന ബോഡിയിൽ.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_ApletHTTP) -- എ AppletHTTP ക്ലാസ്

· msg (സ്ട്രിംഗ്) -- അയക്കേണ്ട സന്ദേശം.

ക്ലാസ് AppletTCP()
'tcp' മോഡ് ആവശ്യമുള്ള ആപ്‌ലെറ്റുകൾക്കൊപ്പമാണ് ഈ ക്ലാസ് ഉപയോഗിക്കുന്നത്. tcp ആപ്‌ലെറ്റ് ആകാം
ൽ രജിസ്റ്റർ ചെയ്തു core.register_service() പ്രവർത്തനം. അവ പ്രോസസ്സിംഗിനായി ഉപയോഗിക്കുന്നു
HAProxy-യുടെ പുറകിലുള്ള സെർവർ പോലെയുള്ള ഒരു tcp സ്ട്രീം.

AppletTCP.c

റിട്ടേൺസ്
A പരിവർത്തനങ്ങൾ ക്ലാസ്

ഈ ആട്രിബ്യൂട്ടിൽ കൺവെർട്ടേഴ്സ് ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു.

AppletTCP.sc

റിട്ടേൺസ്
A പരിവർത്തനങ്ങൾ ക്ലാസ്

ഈ ആട്രിബ്യൂട്ടിൽ കൺവെർട്ടേഴ്സ് ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു. ഈ വസ്തുവിന്റെ പ്രവർത്തനങ്ങൾ
എല്ലായ്പ്പോഴും ഒരു സ്ട്രിംഗ് നൽകുന്നു.

AppletTCP.f

റിട്ടേൺസ്
A ലഭ്യമാക്കുന്നു ക്ലാസ്

ഈ ആട്രിബ്യൂട്ടിൽ ഒരു Fetches ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു.

AppletTCP.sf

റിട്ടേൺസ്
A ലഭ്യമാക്കുന്നു ക്ലാസ്

ഈ ആട്രിബ്യൂട്ടിൽ ഒരു Fetches ക്ലാസ് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കുന്നു.

AppletTCP.getline(applet)
ഈ ഫംഗ്‌ഷൻ സ്ട്രീമിൽ നിന്ന് ഒരു ലൈൻ അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു. ഡാറ്റ എങ്കിൽ
റിട്ടേൺ എന്നതിൽ അവസാനമായി ലഭ്യമായ ഡാറ്റയേക്കാൾ ഒരു അന്തിമ '\n' അടങ്ങിയിട്ടില്ല
സ്ട്രീം അവസാനിക്കുന്നതിന് മുമ്പ്.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_AppletTCP) -- എ AppletTCP ക്ലാസ്

റിട്ടേൺസ്
ഒരു ചരട്. സ്ട്രീമിന്റെ അറ്റത്ത് എത്തിയാൽ ചരട് ശൂന്യമായിരിക്കും.

AppletTCP.receive(applet[, വലിപ്പം])
നിർദ്ദിഷ്ട റീഡിന് അനുസരിച്ച് TCP സ്ട്രീമിൽ നിന്നുള്ള ഡാറ്റ വായിക്കുന്നു വലുപ്പം. ആണെങ്കിൽ വലുപ്പം
കാണുന്നില്ല, ഫംഗ്ഷൻ സ്ട്രീമിലെ എല്ലാ ഉള്ളടക്കവും അവസാനം വരെ വായിക്കാൻ ശ്രമിക്കുന്നു.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_AppletTCP) -- എ AppletTCP ക്ലാസ്

· വലുപ്പം (പൂർണ്ണസംഖ്യ) -- ആവശ്യമായ വായന വലുപ്പം.

റിട്ടേൺസ്
എല്ലായ്‌പ്പോഴും ഒരു സ്ട്രിംഗ് തിരികെ നൽകുക, കണക്ഷൻ അടച്ചിരിക്കുമ്പോൾ സ്‌ട്രിംഗ് ശൂന്യമായിരിക്കും.

AppletTCP.send(appletmsg)
സ്ട്രീമിൽ സന്ദേശം അയയ്ക്കുക.

വാദങ്ങൾ

· ആപ്ലെറ്റ് (class_AppletTCP) -- എ AppletTCP ക്ലാസ്

· msg (സ്ട്രിംഗ്) -- അയക്കേണ്ട സന്ദേശം.

ഉപയോഗപ്രദമായ ധാരാളം ലുവാ ലൈബ്രറികൾ ഇവിടെ കാണാം:

· https://lua-toolbox.com/

റെഡിസ് ആക്സസ്:

· https://github.com/nrk/redis-lua

HAProxy ഉള്ള Redis ലൈബ്രറിയുടെ ഉപയോഗത്തെക്കുറിച്ചുള്ള ഒരു ഉദാഹരണമാണിത്. ഓരോ കോളും ശ്രദ്ധിക്കുക
സോക്കറ്റ് കണക്ഷൻ പരാജയപ്പെടുകയാണെങ്കിൽ ഈ ലൈബ്രറിയുടെ ഏത് പ്രവർത്തനത്തിനും ഒരു പിശക് സംഭവിക്കാം.

-- റെഡിസ് ലൈബ്രറി ലോഡ് ചെയ്യുക
ലോക്കൽ റെഡിസ് = ആവശ്യമാണ് ("റെഡിസ്");

ഫംഗ്‌ഷൻ do_something(txn)

-- പുതിയ tcp സോക്കറ്റ് സൃഷ്ടിക്കുകയും ബന്ധിപ്പിക്കുകയും ചെയ്യുക
ലോക്കൽ tcp = core.tcp();
tcp:ക്രമീകരണം(1);
tcp:connect("127.0.0.1", 6379);

-- ഈ പുതിയ സോക്കറ്റിനൊപ്പം redis ലൈബ്രറി ഉപയോഗിക്കുക
പ്രാദേശിക ക്ലയന്റ് = redis.connect({socket=tcp});
ക്ലയന്റ്:പിംഗ്();

അവസാനിക്കുന്നു

OpenSSL:

· http://mkottman.github.io/luacrypto/index.html

· https://github.com/brunoos/luasec/wiki

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് haproxy-lua ഓൺലൈനായി ഉപയോഗിക്കുക