זוהי הפקודה haproxy-lua שניתן להריץ בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות המרובות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS
תָכְנִית:
שֵׁם
haproxy-lua - haproxy-lua תיעוד
HAPROXY LUA רץ הקשרים
ניתן לעבד את קוד Lua המבוצע ב-HAProxy בשני מצבים עיקריים. הראשון הוא ה
אתחול מצב, והשני הוא ה זמן ריצה מצב.
· בתוך ה אתחול מצב, אנחנו יכולים לבצע פתרונות DNS, אבל אנחנו לא יכולים לבצע שקע I/O.
במצב אתחול זה, HAProxy עדיין נחסמה במהלך ביצוע ה-Lua
תכנית.
· בתוך ה זמן ריצה מצב, אנחנו לא יכולים לבצע פתרונות DNS, אבל אנחנו יכולים להשתמש בשקעים. ה
ביצוע קוד Lua משולב עם עיבוד הבקשות, כך שקוד Lua
נראה שהוא מופעל בחסימה, אבל זה לא המקרה.
קוד Lua נטען בקובץ אחד או יותר. קבצים אלה מכילים קוד ופונקציות ראשיות.
ל-Lua יש 6 הקשרי ביצוע.
1. קובץ Lua גוּף הקשר. זה מבוצע במהלך הטעינה של קובץ Lua ב-
HAProxy [העולמי] סעיף עם ההנחיה lua-load. זה מבוצע באתחול
מצב. סעיף זה משמש להגדרת כריכות Lua ב-HAProxy.
2. הלואה init הקשר. זוהי פונקציית Lua המבוצעת מיד לאחר ה-HAProxy
ניתוח תצורה. הביצוע נמצא במצב אתחול. בהקשר זה ה
סביבת HAProxy כבר אתחולה. זה שימושי כדי לבדוק תצורה, או
אתחול חיבורי שקעים או משימות. פונקציות אלו מוצהרות בגוף
הקשר עם הפונקציה Lua core.register_init(). אב הטיפוס של הפונקציה הוא א
פונקציה פשוטה ללא ערך החזרה וללא פרמטרים, כך: פונקציה fcn().
3. הלואה משימה הקשר. זוהי פונקציית Lua המבוצעת לאחר תחילת ה- HAProxy
מתזמן, ומיד לאחר ההכרזה על המשימה עם הפונקציה Lua
core.register_task(). הקשר זה יכול להיות במקביל לעיבוד התעבורה. זה
מבוצע במצב זמן ריצה. אב הטיפוס של הפונקציה הוא פונקציה פשוטה ללא
ערך החזר וללא פרמטרים, כך: פונקציה fcn().
4. פעולה הקשר. זוהי פונקציית Lua המבוצעת באופן מותנה. פעולות אלו הן
רשום לפי הנחיות Lua "core.register_action()". אב הטיפוס של הלואה
שנקרא פונקציה היא פונקציה עם לא מחזירה כלום ואשר לוקחת אובייקט של
מחלקה TXN כערך. פונקציה fcn(txn).
5. הבאת דגימה הקשר. פונקציה זו לוקחת אובייקט TXN כארגומנט כניסה ו
מחזיר מחרוזת. סוגים אלה של פונקציות אינם יכולים לבצע פונקציית חסימה כלשהי. הֵם
שימושיים לאיסוף חלק מהדגימות המקוריות של HAProxy ולהחזיר את התוצאה.
אב הטיפוס של הפונקציה הוא פונקציה מחרוזת fcn(txn). פונקציות אלה יכולות להיות
רשום עם הפונקציה Lua core.register_fetches(). כל דוגמה-שליפת מוצהרת היא
קידומת המחרוזת "lua.".
הערה: ייתכן שפונקציה זו לא יכולה למצוא את הנתונים הנדרשים במקור
דגימת HAProxy מביאה, במקרה זה, היא לא יכולה להחזיר את התוצאה. המקרה הזה עדיין לא
נתמך
6. מֵמִיר הקשר. זוהי פונקציית Lua שלוקחת מחרוזת כקלט ומחזירה
מחרוזת נוספת כפלט. פונקציות מסוג זה הן חסרות מדינה, ואין להן גישה אליהן
כל הקשר. הם לא מבצעים שום פונקציית חסימה. אב הטיפוס של השיחה הוא פונקציה
מחרוזת fcn(string). ניתן לרשום פונקציה זו עם הפונקציה Lua
core.register_converters(). כל ממיר מוכרז מקבל את הקידומת של המחרוזת "lua.".
HAPROXY LUA שלום בעולם
קובץ התצורה של HAProxy (hello_world.conf):
גלוֹבָּלִי
lua-load hello_world.lua
האזנה פרוקסי
לאגד 127.0.0.1:10001
tcp-request inspect-delay 1s
tcp-request content use-service lua.hello_world
קובץ HAProxy Lua (hello_world.lua):
core.register_service("hello_world", "tcp", function(יישומון)
applet:send("שלום עולם\n")
סוף)
כיצד להפעיל את HAProxy לבדיקת תצורה זו:
./haproxy -f hello_world.conf
במסוף אחר, אתה יכול לבדוק עם telnet:
#:~ telnet 127.0.0.1 10001
שלום עולם
בכיתה הליבה()
מחלקת "הליבה" מכילה את כל פונקציות הליבה של HAProxy. פונקציות אלו שימושיות
לשליטה בזרימת הביצוע, רישום ווים, מניפולציה של מפות גלובליות
או ACL,...
מחלקה "הליבה" מסופקת בעצם עם HAProxy. לא לדרוש קו נדרש ל
משתמש בפונקציות הללו.
המחלקה "הליבה" היא סטטית, לא ניתן ליצור אובייקט חדש מסוג זה.
core.emerg
החזרים
מספר שלם
תכונה זו היא מספר שלם, היא מכילה את הערך של רמת היומן "חירום"
(0).
core.alert
החזרים
מספר שלם
תכונה זו היא מספר שלם, היא מכילה את הערך של "התראה" ברמת היומן (1).
core.crit
החזרים
מספר שלם
תכונה זו היא מספר שלם, היא מכילה את הערך של רמת הלוג "קריטית" (2).
core.err
החזרים
מספר שלם
תכונה זו היא מספר שלם, היא מכילה את הערך של "שגיאה" ברמת הלוג (3).
אזהרה
החזרים
מספר שלם
תכונה זו היא מספר שלם, היא מכילה את הערך של רמת היומן "אזהרה" (4).
core.notice
החזרים
מספר שלם
תכונה זו היא מספר שלם, היא מכילה את הערך של רמת ה-loglevel "הודעה" (5).
core.info
החזרים
מספר שלם
תכונה זו היא מספר שלם, היא מכילה את הערך של רמת ה-loglevel "info" (6).
core.debug
החזרים
מספר שלם
תכונה זו היא מספר שלם, היא מכילה את הערך של רמת ה-loglevel "debug" (7).
core.log(loglevel, msg)
הקשר: body, init, task, action, sample-rech, ממיר
פונקציה זו שולחת יומן. היומן נשלח, בהתאם ל-HAProxy
קובץ תצורה, בשרת ברירת המחדל של syslog אם הוא מוגדר וב-
stderr אם זה מותר.
טיעונים
· רמת יומן (מספר שלם) -- האם רמת היומן משויכת להודעה. זה
מספר בין 0 ל-7.
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת core.emerg, core.alert, core.crit, core.err, core.warning, core.notice,
core.info, core.debug (הגדרות ברמת יומן)
לִרְאוֹת code.Debug
לִרְאוֹת core.Info
לִרְאוֹת core.אזהרה
לִרְאוֹת core.Alert
core.Debug(מסג)
הקשר: body, init, task, action, sample-rech, ממיר
טיעונים
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת היכנס
עושה את אותה עבודה מאשר:
פונקציה לנפות(מסג)
core.log(core.debug, msg)
סוף
core.Info(מסג)
הקשר: body, init, task, action, sample-rech, ממיר
טיעונים
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת היכנס
פונקציה מידע(מסג)
core.log(core.info, msg)
סוף
core.אזהרה(מסג)
הקשר: body, init, task, action, sample-rech, ממיר
טיעונים
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת היכנס
פונקציה אזהרה(מסג)
core.log(core.warning, msg)
סוף
core.Alert(מסג)
הקשר: body, init, task, action, sample-rech, ממיר
טיעונים
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת היכנס
פונקציה ערני(מסג)
core.log(core.alert, msg)
סוף
core.add_acl(שם קובץ, מַפְתֵחַ)
הקשר: init, task, action, sample-fetch, converter
הוסף את ה-ACL מפתח ברשימת ACLs שאליו הקובץ מפנה שם הקובץ.
טיעונים
· שם הקובץ (מחרוזת) -- שם הקובץ שמתייחס לערכי ה-ACL.
· מפתח (מחרוזת) -- המפתח שיתווסף.
core.del_acl(שם קובץ, מַפְתֵחַ)
הקשר: init, task, action, sample-fetch, converter
מחק את ערך ה-ACL אליו מתייחס המפתח מפתח ברשימת ה-ACLs שאליהם מתייחסים
שם הקובץ.
טיעונים
· שם הקובץ (מחרוזת) -- שם הקובץ שמתייחס לערכי ה-ACL.
· מפתח (מחרוזת) -- המפתח שיימחק.
core.del_map(שם קובץ, מַפְתֵחַ)
הקשר: init, task, action, sample-fetch, converter
מחק את ערך המפה באינדקס עם המפתח שצוין ברשימת המפות שאליהן מתייחסים
לפי שם הקובץ שלו.
טיעונים
· שם הקובץ (מחרוזת) -- שם הקובץ שמתייחס לערכי המפה.
· מפתח (מחרוזת) -- המפתח שיימחק.
core.msleep(מילישניות)
הקשר: גוף, התחלה, משימה, פעולה
השמיים core.msleep() מפסיק את ביצוע Lua בין אלפיות שניות שצוינו.
טיעונים
· מילי שניות (מספר שלם) -- אלפיות השנייה הנדרשות.
core.register_action(שם, פעולות, func)
הקשר: גוף
רשום פונקציית Lua שבוצעה כפעולה. ניתן להשתמש בכל הפעולה הרשומה
ב-HAProxy עם הקידומת "lua.". פעולה מקבלת מחלקת אובייקט TXN כקלט.
טיעונים
· שם (מחרוזת) -- הוא השם של הממיר.
· פעולות (שולחן) -- היא טבלת מחרוזת המתארת את פעולות HAProxy מי
רוצה להירשם ל. הפעולות הצפויות הן 'tcp-req', 'tcp-res',
'http-req' או 'http-res'.
· func (פונקציה) -- היא הפונקציה Lua שנקראת לעבוד כממיר.
אב הטיפוס של הפונקציה Lua המשמשת כארגומנט הוא:
function(txn)
·
txn (TXN בכיתה): זֶה is a TXN אובייקט מְשׁוּמָשׁ ל מניפולציה מה היא
בקשה נוכחית או זרם TCP.
הנה, דוגמה לרישום פעולה. הפעולה פשוט לשלוח 'שלום עולם' ב
יומנים.
core.register_action("hello-world", { "tcp-req", "http-req" }, function(txn)
txn:Info("שלום עולם")
סוף)
קוד דוגמה זה משמש בתצורת HAproxy כך:
frontend tcp_frt
מצב tcp
תוכן tcp-request lua.hello-world
חזית http_frt
מצב http
http-request lua.hello-world
core.register_converters(שם, func)
הקשר: גוף
רשום פונקציית Lua המבוצעת כממיר. כל הממירים הרשומים יכולים להיות
בשימוש ב-HAProxy עם הקידומת "lua.". ממיר מקבל מחרוזת כקלט ו
להחזיר מחרוזת כפלט. הפונקציה הרשומה יכולה לקחת עד 9 ערכים כ
פָּרָמֶטֶר. כל הערכים הם מחרוזות.
טיעונים
· שם (מחרוזת) -- הוא השם של הממיר.
· func (פונקציה) -- היא הפונקציה Lua שנקראת לעבוד כממיר.
אב הטיפוס של הפונקציה Lua המשמשת כארגומנט הוא:
function(str, [p1 [, p2 [, ... [, p5]]]])
· str (מחרוזת): זהו ערך הקלט המומר אוטומטית במחרוזת.
· p1 .. p5 (מחרוזת): זוהי רשימה של ארגומנטים של מחרוזת המוצהרת בהרוקס
קובץ תצורה. מספר הארגומנטים אינו עולה על 5. הסדר וה-
האופי של אלה נבחר בדרך כלל על ידי המפתח.
core.register_fetches(שם, func)
הקשר: גוף
רשום פונקציית Lua המבוצעת כאחזור לדוגמה. כל הבאטות המדגם הרשומות
ניתן להשתמש ב-HAProxy עם הקידומת "lua.". אחזור מדגם Lua מחזיר מחרוזת
בתור פלט. הפונקציה הרשומה יכולה לקחת עד 9 ערכים כפרמטר. כל ה
ערך הם מחרוזות.
טיעונים
· שם (מחרוזת) -- הוא השם של הממיר.
· func (פונקציה) -- היא הפונקציה Lua שנקראת לעבוד בתור אחזור לדוגמה.
אב הטיפוס של הפונקציה Lua המשמשת כארגומנט הוא:
פונקציית מחרוזת (txn, [p1 [, p2 [, ... [, p5]]]])
· txn (TXN בכיתה): זהו האובייקט txn המשויך לבקשה הנוכחית.
· p1 .. p5 (מחרוזת): זוהי רשימה של ארגומנטים של מחרוזת המוצהרת בהרוקס
קובץ תצורה. מספר הארגומנטים אינו עולה על 5. הסדר וה-
האופי של אלה נבחר בדרך כלל על ידי המפתח.
· החזרים: מחרוזת המכילה נתונים מסוימים, ot nil אם לא ניתן להחזיר את הערך כעת.
קוד לדוגמא:
core.register_fetches("שלום", function(txn)
החזר "שלום"
סוף)
תצורה לדוגמה של HAProxy:
דוגמה חזיתית
http-request location /%[lua.hello]
core.register_service(שם, מצב, func)
הקשר: גוף
רשום פונקציית Lua המבוצעת כשירות. כל השירות הרשום יכול להיות
בשימוש ב-HAProxy עם הקידומת "lua.". שירות מקבל מחלקת אובייקט כקלט
בהתאם למצב הנדרש.
טיעונים
· שם (מחרוזת) -- הוא השם של הממיר.
· מצב (מחרוזת) -- היא מחרוזת המתארת את המצב הנדרש. רק 'tcp' או
'http' מותרים.
· func (פונקציה) -- היא הפונקציה Lua שנקראת לעבוד כממיר.
אב הטיפוס של הפונקציה Lua המשמשת כארגומנט הוא:
פונקציה (יישומון)
· היישומון היישומון יהיה AppletTCP בכיתה או AppletHTTP בכיתה. זה תלוי בסוג
של יישומון רשום. יישומון רשום עם הערך 'http' עבור ה מצב
פרמטר יקבל א AppletHTTP בכיתה. אם מצב הערך הוא 'tcp', היישומון יהיה
מקבל AppletTCP בכיתה.
אזהרה: לא ניתן לקרוא ליישומונים מסוג 'http' מתוך 'tcp-' ערכי כללים. רק מה היא 'http-'
ערכי כללים מורשים, זה אומר שלא ניתן לקרוא ליישומון HTTP מ-a
פרוקסי במצב tcp. ניתן לקרוא ליישומונים מסוג 'tcp' מכל מקום.
הנה, דוגמה לרישום שירות. השירות פשוט שלח 'שלום עולם' בתור
תגובת http.
core.register_service("hello-world", "http", function(applet)
תגובה מקומית = "שלום עולם!"
יישומון:set_status(200)
applet:add_header("content-length", string.len(response))
applet:add_header("content-type", "text/plain")
applet:start_response()
יישומון:שלח (תגובה)
סוף)
קוד דוגמה זה משמש בתצורת HAproxy כך:
דוגמה חזיתית
http-request use-service lua.hello-world
core.register_init(func)
הקשר: גוף
רשום פונקציה שבוצעה לאחר ניתוח התצורה. זה שימושי ל
לבדוק פרמטרים כלשהם.
טיעונים
· func (פונקציה) -- היא פונקציית Lua שנקראת לעבוד כמאתחל.
אב הטיפוס של הפונקציה Lua המשמשת כארגומנט הוא:
פוּנקצִיָה()
זה לא לוקח קלט, ולא צפוי פלט.
core.register_task(func)
הקשר: body, init, task, action, sample-rech, ממיר
הירשם והתחל במשימה עצמאית. המשימה מתחילה כאשר ה-HAProxy הראשי
מתזמן מתחיל. לדוגמה, ניתן לבצע משימות מסוג זה כדי לבצע מורכבות
בדיקות בריאות.
טיעונים
· func (פונקציה) -- היא פונקציית Lua שנקראת לעבוד כמאתחל.
אב הטיפוס של הפונקציה Lua המשמשת כארגומנט הוא:
פוּנקצִיָה()
זה לא לוקח קלט, ולא צפוי פלט.
core.set_nice(נחמד)
הקשר: משימה, פעולה, דוגמה-שליפה, ממיר
שנה את היופי של המשימה הנוכחית או הפגישה הנוכחית.
טיעונים
· נחמד (מספר שלם) -- הערך הנחמד, עליו להיות בין -1024 ל-1024.
core.set_map(שם קובץ, מַפְתֵחַ, ערך)
הקשר: init, task, action, sample-fetch, converter
הגדר את הערך ערך הקשורים למפתח מפתח במפה שאליה מתייחסים שם הקובץ.
טיעונים
· שם הקובץ (מחרוזת) -- הפניה למפה
· מפתח (מחרוזת) -- המפתח להגדרה או החלפה
· ערך (מחרוזת) -- הערך המשויך
core.sleep(int שניות)
הקשר: גוף, התחלה, משימה, פעולה
השמיים core.sleep() פונקציות עוצרות את ביצוע Lua בין שניות שצוינו.
טיעונים
· שניות (מספר שלם) -- השניות הדרושות.
core.tcp()
הקשר: התחלה, משימה, פעולה
פונקציה זו מחזירה אובייקט חדש של a שקע מעמד.
החזרים
A שֶׁקַע בכיתה אובייקט.
core.done(data)
הקשר: body, init, task, action, sample-rech, ממיר
טיעונים
· נתונים (כל) -- החזר כמה נתונים עבור המתקשר. זה שימושי עם
דוגמיות וממירות דגימות.
מפסיק מיד את הביצוע הנוכחי של Lua וחוזר למתקשר שאולי כן
אחזור לדוגמה, ממיר או פעולה ומחזיר את הערך שצוין (התעלם
לפעולות). הוא משמש כאשר תהליך LUA מסיים את עבודתו ורוצה לתת
החזר את הפקד ל-HAProxy מבלי להפעיל את הקוד שנותר. ניתן לראות זאת כ
"החזרה" מרובת רמות.
core.yield()
הקשר: משימה, פעולה, דוגמה-שליפה, ממיר
החזירו את היד ללוח הזמנים של HAProxy. הוא משמש בעת עיבוד LUA
גוזל זמן עיבוד רב.
בכיתה מביאים()
מחלקה זו מכילה הרבה שליפות פנימיות של דגימות HAProxy. ראה את HAProxy
תיעוד "configuration.txt" למידע נוסף על השימוש בה. הם
הפרקים 7.3.2 עד 7.3.6.
אזהרה חלק מהשליפות לדוגמה אינן זמינות בהקשר כלשהו. מגבלות אלו
מצוינים בתיעוד זה כאשר הם שימושיים.
לִרְאוֹת TXN.f
לִרְאוֹת TXN.sf
השלפות שימושיות עבור:
· לקבל זמן מערכת,
· לקבל משתנה סביבה,
· לקבל מספרים אקראיים,
· מצב backend ידוע כמו מספר המשתמשים בתור או מספרם
נוצרו קשרים,
· מידע לקוח כמו מקור ip או יעד,
· להתמודד עם שולחנות מקל,
· מידע SSL מבוסס,
· מידע HTTP כמו כותרות או שיטה.
function action(txn)
-- קבל מקור IP
לקוח מקומי = txn.f:src()
סוף
בכיתה ממירים()
מחלקה זו מכילה הרבה ממירי מדגם HAProxy פנימיים. ראה את HAProxy
תיעוד "configuration.txt" למידע נוסף על השימוש בה. זה ה
פרק 7.3.1.
לִרְאוֹת TXN.c
לִרְאוֹת TXN.sc
ממירים מספקים טרנספורמציה ממלכתית. הם שימושיים עבור:
· המרת קלט ל-base64,
· החלת hash על מחרוזת קלט (djb2, crc32, sdbm, wt6),
· עיצוב תאריך,
· json escape,
· חילוץ שפה מועדפת תוך השוואה בין שתי רשימות,
· פנה לתווים תחתונים או עליונים,
· להתמודד עם שולחנות מקל.
בכיתה עָרוּץ()
HAProxy משתמשת בשני מאגרים לעיבוד הבקשות. הראשון משמש
עם נתוני הבקשה (מהלקוח לשרת) והשני משמש עבור
נתוני התגובה (מהשרת ללקוח).
כל מאגר מכיל שני סוגי נתונים. הסוג הראשון הוא הנתונים הנכנסים הממתינים
לעיבוד. החלק השני הוא הנתונים היוצאים שכבר מעובדים. בְּדֶרֶך כְּלַל,
הנתונים הנכנסים מעובדים, לאחר שהם מתויגים כנתונים יוצאים, ולבסוף הם
נשלח. הפונקציות הבאות מספקות כלים לתפעול נתונים אלה ב-a
מאגר.
התרשים הבא מראה היכן מיושמות פונקציית מחלקת הערוץ.
אזהרה: לא ניתן לקרוא מהתגובה בפעולה בקשה, וזהו
לא ניתן לקרוא עבור ערוץ הבקשה בפעולת תגובה.
[תמונה]
Channel.dup(channel)
פונקציה זו מחזירה מחרוזת המכילה את כל המאגר. הנתונים לא
להסיר מהמאגר וניתן לעבד אותו מחדש מאוחר יותר.
אם המאגר לא יכול לקבל נתונים נוספים, מוחזר ערך 'אפס'.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
החזרים
מחרוזת המכילה את כל הנתונים הזמינים או אפסית.
Channel.get(channel)
פונקציה זו מחזירה מחרוזת המכילה את כל המאגר. הנתונים נצרכים
מהמאגר.
אם המאגר לא יכול לקבל נתונים נוספים, מוחזר ערך 'אפס'.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
החזרים
מחרוזת המכילה את כל הנתונים הזמינים או אפסית.
Channel.getline(channel)
פונקציה זו מחזירה מחרוזת המכילה את השורה הראשונה של המאגר. הנתונים
נצרך. אם הנתונים המוחזרים אינם מכילים 'n' סופי, ההנחה היא שלו
הנתונים הזמינים האחרונים במאגר.
אם המאגר לא יכול לקבל נתונים נוספים, מוחזר ערך 'אפס'.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
החזרים
מחרוזת המכילה את השורה הזמינה או אפסית.
Channel.set(channel, חוּט)
פונקציה זו מחליפה את תוכן המאגר במחרוזת. הפונקציה חוזרת
האורך המועתק, אחרת, הוא מחזיר -1.
ערכת הנתונים עם פונקציה זו אינה נשלחת. הם מחכים לסוף HAProxy
עיבוד, כך שהמאגר יכול להיות מלא.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
· מחרוזת (מחרוזת) -- הנתונים שיישלחו.
החזרים
מספר שלם המכיל את כמות הבתים שהועתקו או -1.
Channel.append(channel, חוּט)
פונקציה זו מוסיפה את ארגומנט המחרוזת לתוכן המאגר. הפונקציה
מחזיר את האורך שהועתק, אחרת, הוא מחזיר -1.
ערכת הנתונים עם פונקציה זו אינה נשלחת. הם מחכים לסוף HAProxy
עיבוד, כך שהמאגר יכול להיות מלא.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
· מחרוזת (מחרוזת) -- הנתונים שיישלחו.
החזרים
מספר שלם המכיל את כמות הבתים שהועתקו או -1.
Channel.send(channel, חוּט)
פונקציה זו דרשה שליחה מיידית של הנתונים. אלא אם כן החיבור
סגור, המאגר נשטף באופן קבוע וניתן לשלוח את כל המחרוזת.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
· מחרוזת (מחרוזת) -- הנתונים שיישלחו.
החזרים
מספר שלם המכיל את כמות הבתים שהועתקו או -1.
Channel.get_in_length(channel)
פונקציה זו מחזירה את אורך חלק הקלט של המאגר.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
החזרים
מספר שלם המכיל את כמות הבתים הזמינים.
Channel.get_out_length(channel)
פונקציה זו מחזירה את אורך חלק הפלט של המאגר.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
החזרים
מספר שלם המכיל את כמות הבתים הזמינים.
Channel.forward(channel, int)
פונקציה זו מעבירה בתים מחלק הקלט של המאגר לחלק הפלט.
טיעונים
· ערוץ (class_channel) -- הערוץ שעבר מניפולציות.
· int (מספר שלם) -- כמות הנתונים שתועבר.
בכיתה HTTP()
מחלקה זו מכילה את כל פונקציות המניפולציה של HTTP.
HTTP.req_get_headers(http)
מחזירה מערך המכיל את כל כותרות הבקשות.
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
החזרים
מערך של כותרות.
לִרְאוֹת HTTP.res_get_headers()
זו הצורה של המערך המוחזר:
HTTP:req_get_headers()[' '][ ] = " "
hdr מקומי = HTTP:req_get_headers()
hdr["host"][0] = "www.test.com"
hdr["accept"][0] = "audio/basic q=1"
hdr["accept"][1] = "audio/*, q=0.2"
hdr["accept"][2] = "*/*, q=0.1"
HTTP.res_get_headers(http)
מחזירה מערך המכיל את כל כותרות התגובה.
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
החזרים
מערך של כותרות.
לִרְאוֹת HTTP.req_get_headers()
זו הצורה של המערך המוחזר:
HTTP:res_get_headers()[' '][ ] = " "
hdr מקומי = HTTP:req_get_headers()
hdr["host"][0] = "www.test.com"
hdr["accept"][0] = "audio/basic q=1"
hdr["accept"][1] = "audio/*, q=0.2"
hdr["accept"][2] = "*.*, q=0.1"
HTTP.req_add_header(http, שם, ערך)
מוסיף שדה כותרת HTTP בבקשה ששמה מצוין ב"שם" ו
שערכו מוגדר ב"ערך".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
· ערך (מחרוזת) -- ערך הכותרת.
לִרְאוֹת HTTP.res_add_header()
HTTP.res_add_header(http, שם, ערך)
מוסיף שדה כותרת HTTP בתגובה ששמה מצוין ב"שם" ו
שערכו מוגדר ב"ערך".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
· ערך (מחרוזת) -- ערך הכותרת.
לִרְאוֹת HTTP.req_add_header()
HTTP.req_del_header(http, שֵׁם)
מסיר את כל שדות כותרות ה-HTTP בבקשה ששמם מצוין ב"שם".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
לִרְאוֹת HTTP.res_del_header()
HTTP.res_del_header(http, שֵׁם)
מסיר את כל שדות כותרות ה-HTTP בתגובה ששמם מצוין ב"שם".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
לִרְאוֹת HTTP.req_del_header()
HTTP.req_set_header(http, שם, ערך)
משתנה זה מחליף את כל המופעים של כל הכותרות "שם", רק באחת המכילה
הערך".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
· ערך (מחרוזת) -- ערך הכותרת.
לִרְאוֹת HTTP.res_set_header()
פונקציה זו עושה את אותה עבודה כמו הקוד הבא:
פונקציה fcn(txn)
TXN.http:req_del_header("header")
TXN.http:req_add_header("header", "value")
סוף
HTTP.res_set_header(http, שם, ערך)
משתנה זה מחליף את כל המופעים של כל הכותרות "שם", רק באחת המכילה
הערך".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
· ערך (מחרוזת) -- ערך הכותרת.
לִרְאוֹת HTTP.req_rep_header()
HTTP.req_rep_header(http, שם, רגקס, החלף)
מתאים לביטוי הרגולרי בכל המופעים של שדה הכותרת "שם" בהתאם
ל-"regex", ומחליף אותם בארגומנט "replace". ערך ההחלפה
יכול להכיל הפניות אחורה כמו 1, 2, ... פונקציה זו פועלת עם הבקשה.
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
· regex (מחרוזת) -- הביטוי הרגולרי ההתאמה.
· להחליף (מחרוזת) -- ערך ההחלפה.
לִרְאוֹת HTTP.res_rep_header()
HTTP.res_rep_header(http, שם, רגקס, חוּט)
מתאים לביטוי הרגולרי בכל המופעים של שדה הכותרת "שם" בהתאם
ל-"regex", ומחליף אותם בארגומנט "replace". ערך ההחלפה
יכול להכיל הפניות אחורה כמו 1, 2, ... פונקציה זו פועלת עם הבקשה.
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
· regex (מחרוזת) -- הביטוי הרגולרי ההתאמה.
· להחליף (מחרוזת) -- ערך ההחלפה.
לִרְאוֹת HTTP.req_replace_header()
HTTP.req_replace_value(http, שם, רגקס, החלף)
עובד כמו "HTTP.req_replace_header()" אלא שהוא תואם את הביטוי הרגולרי נגד
כל ערך מופרד בפסיק של שדה הכותרת "שם" במקום כולו
כותרת.
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
· regex (מחרוזת) -- הביטוי הרגולרי ההתאמה.
· להחליף (מחרוזת) -- ערך ההחלפה.
לִרְאוֹת HTTP.req_replace_header()
לִרְאוֹת HTTP.res_replace_value()
HTTP.res_replace_value(http, שם, רגקס, החלף)
עובד כמו "HTTP.res_replace_header()" אלא שהוא תואם את הביטוי הרגולרי נגד
כל ערך מופרד בפסיק של שדה הכותרת "שם" במקום כולו
כותרת.
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שם (מחרוזת) -- שם הכותרת.
· regex (מחרוזת) -- הביטוי הרגולרי ההתאמה.
· להחליף (מחרוזת) -- ערך ההחלפה.
לִרְאוֹת HTTP.res_replace_header()
לִרְאוֹת HTTP.req_replace_value()
HTTP.req_set_method(http, שיטה)
משכתב את שיטת הבקשה עם הפרמטר "שיטה".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שיטה (מחרוזת) -- השיטה החדשה.
HTTP.req_set_path(http, נתיב)
משכתב את נתיב הבקשה עם הפרמטר "נתיב".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· נתיב (מחרוזת) -- הדרך החדשה.
HTTP.req_set_query(http, שאילתא)
משכתב את מחרוזת השאילתה של הבקשה המופיעה אחרי סימן השאלה הראשון
("?") עם הפרמטר "שאילתה".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· שאלה (מחרוזת) -- השאילתה החדשה.
HTTP.req_set_uri(http, אורי)
משכתב את URI הבקשה עם הפרמטר "uri".
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· של (מחרוזת) -- האורי החדש.
HTTP.res_set_status(http, סטָטוּס)
משכתב את קוד מצב התגובה עם הפרמטר "קוד". שימו לב שהסיבה
מותאם אוטומטית לקוד החדש.
טיעונים
· http (class_http) -- אובייקט ה-http הקשור.
· מצב (מספר שלם) -- קוד סטטוס התגובה החדש.
בכיתה TXN()
המחלקה txn מכילה את כל הפונקציות ביחס לעסקת http או tcp
(שים לב שזרם tcp זהה לעסקת tcp, אבל עסקת HTTP
אינו זהה לזרם tcp).
השימוש במחלקה זו מאפשר לאחזר נתונים מהבקשות, לשנות אותם ו
להעביר אותו.
כל הפונקציות שמספקות מחלקה זו זמינות בהקשר
דגימות-שליפות ו פעולות.
TXN.c
החזרים
An ממירים בכיתה.
תכונה זו מכילה אובייקט מחלקה Converters.
TXN.sc
החזרים
An ממירים בכיתה.
תכונה זו מכילה אובייקט מחלקה Converters. הפונקציות של אובייקט זה
מחזיר תמיד מחרוזת.
TXN.f
החזרים
An מביא בכיתה.
תכונה זו מכילה אובייקט מחלקה Fetches.
TXN.sf
החזרים
An מביא בכיתה.
תכונה זו מכילה אובייקט מחלקה Fetches. הפונקציות של אובייקט זה
מחזיר תמיד מחרוזת.
TXN.req
החזרים
An ערוץ בכיתה.
תכונה זו מכילה אובייקט מחלקת ערוץ עבור מאגר הבקשות.
TXN.res
החזרים
An ערוץ בכיתה.
תכונה זו מכילה אובייקט מחלקת ערוץ עבור מאגר התגובה.
TXN.http
החזרים
An HTTP בכיתה.
תכונה זו מכילה אובייקט מסוג HTTP. זה זמין רק אם יש ל-proxy
"מצב http" מופעל.
TXN.log(TXN, loglevel, msg)
פונקציה זו שולחת יומן. היומן נשלח, בהתאם ל-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.Debug
לִרְאוֹת TXN.Info
לִרְאוֹת TXN. אזהרה
לִרְאוֹת TXN.Alert
TXN.deflog(TXN, msg)
שולח שורת יומן עם רמת היומן המוגדרת כברירת מחדל עבור ה-proxy המשויך ל-
- עסקה.
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת TXN.log
TXN.Debug(txn, msg)
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת TXN.log
עושה את אותה עבודה מאשר:
function Debug(txn, msg)
TXN.log(txn, core.debug, msg)
סוף
TXN.Info(txn, msg)
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת TXN.log
function Debug(txn, msg)
TXN.log(txn, core.info, msg)
סוף
TXN.Warning(txn, msg)
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת TXN.log
function Debug(txn, msg)
TXN.log(txn, core.warning, msg)
סוף
TXN.Alert(txn, msg)
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· msg (מחרוזת) -- תוכן היומן.
לִרְאוֹת TXN.log
function Debug(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, יש, ערך)
ממיר סוג Lua בסוג HAProxy ומאחסן אותו במשתנה .
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· היה (מחרוזת) -- שם המשתנה בהתאם למשתנה HAProxy
תחביר.
· ערך (אטום) -- הנתונים המאוחסנים במשתנה.
TXN.get_var(TXN, var)
מחזירה נתונים המאוחסנים בממיר המשתנה בסוג Lua.
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· היה (מחרוזת) -- שם המשתנה בהתאם למשתנה HAProxy
תחביר.
TXN.get_headers(txn)
פונקציה זו מחזירה מערך של כותרות.
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
החזרים
מערך של כותרות.
TXN.done(txn)
פונקציה זו מפסיקה את העיבוד של העסקה וההפעלה הקשורה.
ניתן להשתמש בו כאשר מזוהה שגיאה קריטית או כדי להפסיק את העיבוד לאחר מכן
חלק מהנתונים הוחזרו ללקוח (למשל: הפניה מחדש).
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
TXN.set_loglevel(txn, רמת יומן)
משמש לשינוי רמת היומן של הבקשה הנוכחית. ה-"loglevel" חייב להיות an
מספר שלם בין 0 ל-7.
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· רמת יומן (מספר שלם) -- רמת היומן הנדרשת. משתנה זה יכול להיות אחד מהם
לִרְאוֹת הליבה.
TXN.set_tos(txn, טוס)
משמש להגדרת ערך השדה TOS או DSCP של מנות שנשלחות ללקוח ל-
ערך שהועבר ב-"tos" בפלטפורמות שתומכות בכך.
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· tos (מספר שלם) -- DSCP של מערכת ההפעלה החדשה של TOS.
TXN.set_mark(txn, סימן)
משמש להגדרת ה-Netfilter MARK על כל החבילות שנשלחות ללקוח לערך
עבר ב"סימן" בפלטפורמות התומכות בכך.
טיעונים
· txn (class_txn) -- אובייקט המחלקה txn המכיל את הנתונים.
· סימן (מספר שלם) -- ערך הסימן.
בכיתה שֶׁקַע()
מחלקה זו חייבת להיות תואמת למחלקה Lua Socket. רק ה'לקוח'
פונקציות זמינות. ראה את התיעוד של Lua Socket:
http://w3.impa.br/~diego/software/luasocket/tcp.html
Socket.close(socket)
סוגר אובייקט TCP. השקע הפנימי המשמש את האובייקט סגור והמקומי
הכתובת שאליה נקשר האובייקט זמינה ליישומים אחרים. לא
פעולות נוספות (למעט קריאות נוספות לשיטת הסגירה) מותרות ב-a
שקע סגור.
טיעונים
· שקע (class_socket) - האם ה-Socket המטופל.
הערה: חשוב לסגור את כל השקעים המשומשים ברגע שאין בהם צורך, שכן, ב
מערכות רבות, כל שקע משתמש במתאר קבצים, שהן מערכת מוגבלת
אֶמְצָעִי. חפצים שנאספו באשפה נסגרים אוטומטית לפני ההשמדה,
אף.
Socket.connect(socket, כתובת[, נמל])
ניסיונות לחבר אובייקט שקע למארח מרוחק.
במקרה של שגיאה, השיטה מחזירה אפס ואחריה מחרוזת המתארת את השגיאה.
במקרה של הצלחה, השיטה מחזירה 1.
טיעונים
· שקע (class_socket) - האם ה-Socket המטופל.
· כתובת (מחרוזת) -- יכול להיות כתובת IP או שם מארח. ראה להלן עבור
עוד מידע.
· נמל (מספר שלם) -- חייב להיות מספר שלם בטווח [1..64K].
החזרים
1 או אפס.
סיומת שדה כתובת מאפשרת להשתמש בפונקציה connect() כדי להתחבר אליה
זרם אחר מאשר TCP. התחביר המכיל כתובת simpleipv4 או ipv6 הוא
בעצם הפורמט הצפוי. פורמט זה דורש את היציאה.
פורמט אחר המקובל הוא נתיב שקע כמו "/socket/path", הוא מאפשר להתחבר
לשקע. מרחבי שמות מופשטים נתמכים עם הקידומת "abns@", ולבסוף
ניתן להעביר filedescriotr עם הקידומת "fd@". הקידומת "ipv4@", "ipv6@"
וגם "unix@" נתמכים. ניתן להעביר את היציאה לתוך המחרוזת. התחביר
"127.0.0.1:1234" תקף. במקרה זה, הפרמטר נמל מתעלמים.
Socket.connect_ssl(socket, כתובת, יציאה)
אותה התנהגות כמו הפונקציה socket:connect, אך משתמשת ב-SSL.
טיעונים
· שקע (class_socket) - האם ה-Socket המטופל.
החזרים
1 או אפס.
Socket.getpeername(socket)
מחזיר מידע על הצד המרוחק של אובייקט לקוח מחובר.
מחזירה מחרוזת עם כתובת ה-IP של העמית, ואחריה את מספר היציאה
עמית משתמש עבור החיבור. במקרה של טעות, השיטה מחזירה אפס.
טיעונים
· שקע (class_socket) - האם ה-Socket המטופל.
החזרים
מחרוזת המכילה את מידע השרת.
Socket.getsockname(socket)
מחזירה את פרטי הכתובת המקומית המשויכים לאובייקט.
השיטה מחזירה מחרוזת עם כתובת IP מקומית ומספר עם היציאה. ב
במקרה של שגיאה, השיטה מחזירה אפס.
טיעונים
· שקע (class_socket) - האם ה-Socket המטופל.
החזרים
מחרוזת המכילה את פרטי הלקוח.
Socket.receive(socket[, תבנית[, קידומת]])
קורא נתונים מאובייקט לקוח, בהתאם לדפוס הקריאה שצוין. דפוסים
עקוב אחר פורמט ה-I/O של קובץ Lua, וההבדל בביצועים בין כולם
דפוסים זניחים.
טיעונים
· שקע (class_socket) - האם ה-Socket המטופל.
· דפוס (מחרוזת|מספר שלם) - תאר מה נדרש (ראה להלן).
· קידומת (מחרוזת) -- מחרוזת שתהיה קידומת הנתונים המוחזרים.
החזרים
מחרוזת המכילה את הנתונים הנדרשים או אפסית.
הדפוס יכול להיות כל אחד מהאפשרויות הבאות:
·
`*א`: קורא החל מ- מה היא שקע עד מה היא הקשר is סגור. לא
מבוצע תרגום סוף שורה;
·
`*ל`: קורא a קו of טֶקסט החל מ- מה היא שקע השמיים קו is הסתיים by a
תו LF (ASCII 10), אופציונלי לפניו תו CR (ASCII 13).
התווים CR ו-LF אינם כלולים בשורה המוחזרת. למעשה,
התבנית מתעלמת מכל תווי ה-CR. זהו דפוס ברירת המחדל.
·
מספר: גורמים מה היא שיטה ל לקרוא a מפורט מספר of בתים החל מ- מה היא
שֶׁקַע. קידומת היא מחרוזת אופציונלית שיש לשרשר להתחלה
של כל הנתונים שהתקבלו לפני ההחזרה.
· ריק: אם התבנית נשארת ריקה, אפשרות ברירת המחדל היא *l.
אם מצליח, השיטה מחזירה את התבנית שהתקבלה. במקרה של טעות, ה
השיטה מחזירה אפס ואחריה הודעת שגיאה שיכולה להיות המחרוזת 'סגורה' פנימה
במקרה שהחיבור נסגר לפני השלמת השידור או המחרוזת
'פסק זמן' למקרה שהיה פסק זמן במהלך הפעולה. כמו כן, לאחר השגיאה
הודעה, הפונקציה מחזירה את התוצאה החלקית של השידור.
הערה חשובה: פונקציה זו שונתה באופן חמור. זה נהג לתמוך במספר
דפוסים (אבל מעולם לא ראיתי תכונה זו בשימוש) ועכשיו זה כבר לא.
תוצאות חלקיות היו מוחזרות באותו אופן כמו תוצאות מוצלחות. זֶה
התכונה האחרונה הפרה את הרעיון שכל הפונקציות צריכות להחזיר אפס בשגיאה. לכן
גם זה השתנה.
Socket.send(socket, נתונים[, הַתחָלָה[, סוֹף]])
שולח נתונים דרך אובייקט הלקוח.
טיעונים
· שקע (class_socket) - האם ה-Socket המטופל.
· נתונים (מחרוזת) -- הנתונים שיישלחו.
· התחלה (מספר שלם) -- מיקום ההתחלה במאגר הנתונים אשר יהיה
להישלח.
· סוף (מספר שלם) -- מיקום הקצה במאגר הנתונים שיהיה
נשלח.
החזרים
ראה למטה.
נתונים הם המחרוזת שיש לשלוח. הארגומנטים האופציונליים i ו-j עובדים בדיוק כמו ה-
פונקציית string.sub Lua סטנדרטית כדי לאפשר את הבחירה של מחרוזת משנה להישלח.
אם היא מצליחה, השיטה מחזירה את האינדקס של הבית האחרון בתוך [התחלה, סוף]
שנשלח. שימו לב שאם ההתחלה היא 1 או נעדרת, זהו למעשה ה-
המספר הכולל של בתים שנשלחו. במקרה של שגיאה, השיטה מחזירה אפס, ואחריה
הודעת שגיאה, ואחריה האינדקס של הביט האחרון בתוך [התחלה, סיום] זה
נשלח. אולי תרצה לנסות שוב מהבייט שלאחר מכן. הטעות
ניתן 'לסגור' הודעה במקרה שהחיבור נסגר לפני השידור
הושלם או המחרוזת 'פסק זמן' למקרה שהיה פסק זמן במהלך
פעולה.
הערה: הפלט אינו מאוחסן. עבור מחרוזות קטנות, תמיד עדיף לשרשור
אותם ב-Lua (עם המפעיל '..') ושלח את התוצאה בשיחה אחת במקום
קורא לשיטה מספר פעמים.
Socket.setoption(socket, אוֹפְּצִיָה[, ערך])
רק מיושם עבור תאימות, cal זה לא עושה כלום.
Socket.settimeout(socket, ערך[, מצב])
משנה את ערכי הזמן הקצוב עבור האובייקט. כל פעולות הקלט/פלט חוסמות. זֶה
הוא שכל קריאה לשיטות שליחה, קבלה וקבלה תיחסם ללא הגבלת זמן,
עד לסיום הפעולה. שיטת settimeout מגדירה מגבלה על הכמות
של זמן ששיטות הקלט/פלט יכולות לחסום. כאשר חלף זמן קצוב, המושפע
שיטות מוותרות ונכשלות עם קוד שגיאה.
משך הזמן להמתנה מצוין כפרמטר הערך, בשניות.
מצבי הזמן הקצוב מיושמים בוט, הזמן הקצוב היחיד שניתן להגדרה הוא חוסר הפעילות
זמן המתנה להשלמת השליחה של המאגר הפנימי או המתנה לקבלת נתונים.
טיעונים
· שקע (class_socket) - האם ה-Socket המטופל.
· ערך (מספר שלם) -- ערך הזמן הקצוב.
בכיתה מַפָּה()
מחלקה זו מאפשרת לבצע חיפוש מסוים במפות HAProxy. המפות המוצהרות יכולות להיות
שונה במהלך זמן הריצה דרך שקע הניהול HAProxy.
ברירת מחדל = "ארה"ב
- צור וטען מפה
geo = Map.new("geo.map", Map.ip);
-- צור אחזור חדש שמחזיר את מדינת המשתמש
core.register_fetches("country", function(txn)
src מקומי;
לוק מקומי;
src = txn.f:fhdr("x-forwarded-for");
if (src == nil) אז
src = txn.f:src()
if (src == nil) אז
החזר ברירת מחדל;
סוף
סוף
-- בצע חיפוש
loc = geo:lookup(src);
אם (לוק == אפס) אז
החזר ברירת מחדל;
סוף
לחזור loc;
ח);
Map.int
עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.ip עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.str
עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.beg
עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.sub
עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.dir
עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.dom
עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.end
עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.reg
עיין בקובץ HAProxy configuration.txt, פרק "שימוש ב-ACL והבאת דוגמאות"
וכן תת פרק "יסודות ACL" כדי להבין את שיטת התאמת הדפוסים הזו.
Map.new(file, שיטה)
יוצר וטען מפה.
טיעונים
· פילה (מחרוזת) - האם הקובץ מכיל את המפה.
· שיטה (מספר שלם) -- האם שיטת התאמת דפוסי המפה. ראה את התכונות
של כיתת מפה.
החזרים
אובייקט מפת מחלקה.
לִרְאוֹת תכונות המפה.
Map.lookup(map, str)
בצע חיפוש במפה.
טיעונים
· מַפָּה (מפת_כיתה) -- האם אובייקט מפת הכיתה.
· str (מחרוזת) -- האם המחרוזת משמשת כמפתח.
החזרים
מחרוזת המכילה את התוצאה או אפס אם אין התאמה.
Map.slookup(map, str)
בצע חיפוש במפה.
טיעונים
· מַפָּה (מפת_כיתה) -- האם אובייקט מפת הכיתה.
· str (מחרוזת) -- האם המחרוזת משמשת כמפתח.
החזרים
מחרוזת המכילה את התוצאה או מחרוזת ריקה אם אין התאמה.
בכיתה AppletHTTP()
מחלקה זו משמשת עם יישומונים הדורשים מצב 'http'. יישומון http יכול
להיות רשום עם core.register_service() פוּנקצִיָה. הם משמשים עבור
עיבוד בקשת http כמו שרת בחלק האחורי של HAProxy.
זהו קוד לדוגמה של hello world:
core.register_service("hello-world", "http", function(applet)
תגובה מקומית = "שלום עולם!"
יישומון:set_status(200)
applet:add_header("content-length", string.len(response))
applet:add_header("content-type", "text/plain")
applet:start_response()
יישומון:שלח (תגובה)
סוף)
AppletHTTP.c
החזרים
A ממירים בכיתה
תכונה זו מכילה אובייקט מחלקה Converters.
AppletHTTP.sc
החזרים
A ממירים בכיתה
תכונה זו מכילה אובייקט מחלקה Converters. הפונקציות של אובייקט זה
מחזיר תמיד מחרוזת.
AppletHTTP.f
החזרים
A מביא בכיתה
תכונה זו מכילה אובייקט מחלקה Fetches. שים לב שביצוע היישומון
מקום אינו יכול לגשת לעסקת הליבה של HAProxy חוקית, אז דוגמה מסוימת
פקות הקשורות לערכים התלויים ב-HTTP (hdr, path, ...) אינם זמינים.
AppletHTTP.sf
החזרים
A מביא בכיתה
תכונה זו מכילה אובייקט מחלקה Fetches. הפונקציות של אובייקט זה
מחזיר תמיד מחרוזת. שימו לב שמקום הביצוע של היישומון לא יכול לגשת ל-a
טרנזקציית HTTP הליבה של HAProxy חוקית, אז כמה פקקים לדוגמה הקשורים ל-HTTP
ערכים תלויים (hdr, נתיב, ...) אינם זמינים.
שיטת AppletHTTP
החזרים
מחרוזת
שיטת התכונה מחזירה מחרוזת המכילה את שיטת ה-HTTP.
AppletHTTP.version
החזרים
מחרוזת
גרסת התכונה, מחזירה מחרוזת המכילה את גרסת בקשת ה-HTTP.
AppletHTTP.path
החזרים
מחרוזת
נתיב התכונה מחזיר מחרוזת המכילה את נתיב בקשת ה-HTTP.
AppletHTTP.qs
החזרים
מחרוזת
התכונה qs מחזירה מחרוזת המכילה את מחרוזת שאילתת ה-HTTP.
AppletHTTP.length
החזרים
מספר שלם
אורך התכונה מחזיר מספר שלם המכיל את אורך גוף ה-HTTP.
כותרות AppletHTTP
החזרים
מערך
כותרות התכונה מחזירות מערך המכיל את כותרות ה-HTTP. הכותרת
השמות תמיד באותיות קטנות. כשם הכותרת ניתן להיתקל ביותר מ
פעם אחת בכל בקשה, הערך מתווסף עם 0 כערך האינדקס הראשון. המערך
יש את הטופס הזה:
AppletHTTP.headers[' '][ ] = " "
AppletHTTP.headers["host"][0] = "www.test.com"
AppletHTTP.headers["accept"][0] = "audio/basic q=1"
AppletHTTP.headers["accept"][1] = "audio/*, q=0.2"
AppletHTTP.headers["accept"][2] = "*/*, q=0.1"
כותרות AppletHTTP
מכיל מערך המכיל את כל כותרות הבקשות.
AppletHTTP.set_status(applet, קוד)
פונקציה זו מגדירה את קוד מצב ה-HTTP עבור התגובה. הקוד המותר הוא מ
100 ל599.
טיעונים
· היישומון (class_AppletHTTP) -- אן AppletHTTP בכיתה
· קוד (מספר שלם) -- קוד המצב שהוחזר ללקוח.
AppletHTTP.add_header(יישומון, שם, ערך)
פונקציה זו הוסף כותרת בתגובה. כותרות משוכפלות אינן מכווצות.
הכותרת המיוחדת אורך תוכן משמש לקביעת אורך התגובה. אם זה
לא קיים, א קידוד העברה: נתח מוגדר, וכל הכתיבה מהפונקציה
AppletHTTP:send() להפוך לנתח.
טיעונים
· היישומון (class_AppletHTTP) -- אן AppletHTTP בכיתה
· שם (מחרוזת) -- שם הכותרת
· ערך (מחרוזת) -- ערך הכותרת
AppletHTTP.start_response(יישומון)
פונקציה זו מציינת למנוע ה-HTTP שהוא יכול לעבד ולשלוח את
כותרות תגובה. לאחר הקריאה הזו לא נוכל להוסיף כותרות לתגובה; אָנוּ
לא יכול להשתמש ב- AppletHTTP:send() לתפקד אם AppletHTTP:start_response() לא
שקוראים לו.
טיעונים
· היישומון (class_AppletHTTP) -- אן AppletHTTP בכיתה
AppletHTTP.getline(applet)
פונקציה זו מחזירה מחרוזת המכילה שורה אחת מגוף http. אם הנתונים
המוחזר אינו מכיל '\n' סופי שהוא ההנחה שלו מאשר הנתונים הזמינים האחרונים שלו
לפני סוף הזרם.
טיעונים
· היישומון (class_AppletHTTP) -- אן AppletHTTP בכיתה
החזרים
מחרוזת. המחרוזת יכולה להיות ריקה אם נגיע לסוף הזרם.
AppletHTTP.receive(applet[, גודל])
קורא נתונים מגוף ה-HTTP, בהתאם לקריאה שצוינה גודל. אם גודל is
חסר, הפונקציה מנסה לקרוא את כל תוכן הזרם עד הסוף. אם
מה היא גודל גדול יותר מגוף http, הוא מחזיר את כמות הנתונים הזמינה.
טיעונים
· היישומון (class_AppletHTTP) -- אן AppletHTTP בכיתה
· גודל (מספר שלם) -- גודל הקריאה הנדרש.
החזרים
תמיד תחזיר מחרוזת, המחרוזת יכולה להיות ריקה אם החיבור סגור.
AppletHTTP.send(applet, msg)
לשלוח את ההודעה msg בגוף הבקשה http.
טיעונים
· היישומון (class_AppletHTTP) -- אן AppletHTTP בכיתה
· msg (מחרוזת) -- ההודעה שיש לשלוח.
בכיתה AppletTCP()
מחלקה זו משמשת עם יישומונים הדורשים מצב 'tcp'. יישומון tcp יכול להיות
רשום ב- core.register_service() פוּנקצִיָה. הם משמשים לעיבוד
זרם tcp כמו שרת בחלק האחורי של HAProxy.
AppletTCP.c
החזרים
A ממירים בכיתה
תכונה זו מכילה אובייקט מחלקה Converters.
AppletTCP.sc
החזרים
A ממירים בכיתה
תכונה זו מכילה אובייקט מחלקה Converters. הפונקציות של אובייקט זה
מחזיר תמיד מחרוזת.
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 (מחרוזת) -- ההודעה שיש לשלוח.
ניתן למצוא הרבה ספריות lua שימושיות כאן:
· https://lua-toolbox.com/
גישה Redis:
· https://github.com/nrk/redis-lua
זוהי דוגמה לגבי השימוש בספריית Redis עם HAProxy. שימו לב שכל שיחה
של כל פונקציה של ספרייה זו יכול לזרוק שגיאה אם חיבור השקע נכשל.
-- טען את ספריית redis
local redis = require("redis");
function do_something(txn)
- צור וחבר שקע tcp חדש
מקומי tcp = core.tcp();
tcp:קביעת פסק זמן(1);
tcp:connect("127.0.0.1", 6379);
-- השתמש בספריית redis עם השקע החדש הזה
לקוח מקומי = redis.connect({socket=tcp});
client:ping();
סוף
OpenSSL:
· http://mkottman.github.io/luacrypto/index.html
· https://github.com/brunoos/luasec/wiki
השתמש ב-haproxy-lua באינטרנט באמצעות שירותי onworks.net