שימוש ב־`recover`

חלק מהיחידה לוגיקה וזרימת התוכנית במסלול ה-GO של Coddy. שיעור 43 מתוך 68.

בעוד ש־panic עוצרת את התוכנית שלך מיד, Go מספקת דרך להחזיר את השליטה באמצעות הפונקציה recover. הפונקציה recover מאפשרת לך לתפוס panic ולטפל בו בצורה מסודרת, וכך למנוע מהתוכנית כולה לקרוס.

עם זאת, ל־recover יש דרישה ספציפית מאוד: אפשר להשתמש בו רק בתוך פונקציה דחויה. כשמתרחשת בהלה, Go מבצעת את כל הפונקציות הדחויות לפני שהתוכנית מסתיימת, וכך נותנת ל־recover הזדמנות ליירט את הבהלה:

func riskyFunction() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    
    panic("something went wrong!")
}

הפונקציה recover מחזירה את הערך שהועבר אל panic, או nil אם לא התרחשה פאניקה. כך אפשר לבדוק אם התרחשה פאניקה ולנקוט פעולה מתאימה, כגון רישום השגיאה או ביצוע פעולות ניקוי.

בדומה ל־panic, יש להשתמש ב־recover במשורה ב־Go. לרוב משתמשים בו בתרחישים כמו שרתי אינטרנט, שבהם רוצים למנוע מ־panic של בקשה אחת להפיל את השרת כולו, וכך לאפשר לו להמשיך לטפל בבקשות אחרות.

אתגר

קל

בנו מטפל בבקשות לשרת אינטרנט שמשתמש ב־recover כדי לטפל בפאניקות בצורה מסודרת ולמנוע קריסה של השרת כולו. האתגר הזה מדגים כיצד להשתמש ב־recover בתוך פונקציה דחויה כדי ללכוד פאניקות ולשמור על יציבות השרת.

תקבלו שתי קלטים:

מחרוזת המכילה פרטי בקשה בתבנית "endpoint,method,action" (לדוגמה, "/api/users,GET,process")
מחרוזת המכילה תצורת שרת בתבנית "server_name,max_requests" (לדוגמה, "WebServer,100")

המשימה שלכם היא:

לנתח את הקלט הראשון באמצעות פיצול לפי פסיקים כדי לקבל את נקודת הקצה, השיטה והפעולה
לנתח את הקלט השני באמצעות פיצול לפי פסיקים כדי לקבל את שם השרת ואת מספר הבקשות המרבי
להמיר את מחרוזת מספר הבקשות המרבי למספר שלם
ליצור פונקציה בשם handleRequest שמקבלת את נקודת הקצה, השיטה, הפעולה ושם השרת כפרמטרים
בתוך handleRequest, להוסיף פונקציה דחויה שמשתמשת ב־recover כדי ללכוד פאניקות:
- אם פאניקה נתפסה (הערך שמחזירה recover אינו nil), להדפיס: "Server [server_name] recovered from panic: [panic_value]"
- לאחר הטיפול בפאניקה, להדפיס: "Request handling completed safely"
לאחר הפונקציה הדחויה, לדמות עיבוד בקשה בהתאם לפעולה:
- אם הפעולה היא "process": להדפיס "Processing [method] request to [endpoint]"
- אם הפעולה היא "panic_nil": להדפיס "Attempting dangerous operation" ואז לקרוא ל־panic("nil pointer access")
- אם הפעולה היא "panic_overflow": להדפיס "Attempting resource allocation" ואז לקרוא ל־panic("memory overflow")
- אם הפעולה היא "panic_timeout": להדפיס "Attempting database connection" ואז לקרוא ל־panic("connection timeout")
- לכל פעולה אחרת: להדפיס "Unknown action: [action]" ואז לקרוא ל־panic("invalid action")
בפונקציה הראשית, להדפיס את הודעת הפעלת השרת: "Starting [server_name] with max [max_requests] requests"
לקרוא לפונקציה handleRequest עם הפרמטרים שנותחו
לאחר הקריאה לפונקציה, להדפיס את מצב השרת: "Server [server_name] is still running"
לבסוף, להדפיס סיכום:
- "Server Summary:"
- "Name: [server_name]"
- "Max Requests: [max_requests]"
- "Last Request: [method] [endpoint]"
- "Action Performed: [action]"
- "Status: Operational"

השתמשו בחבילה strings כדי לפצל את מחרוזות הקלט לפי פסיקים, ובחבילה strconv כדי להמיר את מחרוזת מספר הבקשות המרבי למספר שלם. האתגר הזה מדגים כיצד recover מאפשר לשרתים לטפל בפאניקות בלתי צפויות בצורה מסודרת, ולמנוע מכשלים של בקשות בודדות להפיל את המערכת כולה.

נסו בעצמכם

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	// קרא את הקלט
	var requestDetails string
	var serverConfig string
	fmt.Scanln(&requestDetails)
	fmt.Scanln(&serverConfig)
	
	// נתח את פרטי הבקשה
	requestParts := strings.Split(requestDetails, ",")
	endpoint := requestParts[0]
	method := requestParts[1]
	action := requestParts[2]
	
	// נתח את תצורת השרת
	configParts := strings.Split(serverConfig, ",")
	serverName := configParts[0]
	maxRequests, _ := strconv.Atoi(configParts[1])
	
	// TODO: כתוב את הקוד שלך למטה
	// צור את הפונקציה handleRequest עם מנגנון recover
	// הדפס הודעה על הפעלת השרת
	// קרא לפונקציה handleRequest
	// הדפס את מצב השרת וסיכום
	
}