Go SDK की त्रुटियाँ संभालें और बाधित टास्क रिकवर करें

Go 1.22 या बाद का संस्करण और आधिकारिक solvethree.com/sdk मॉड्यूल का संस्करण v0.1.0 इस्तेमाल करें। सेटअप के लिए Go इंटीग्रेशन निर्देश देखें।

सर्वर-साइड एनवायरनमेंट वेरिएबल SOLVETHREE_API_KEY और SOLVETHREE_PROXY सेट करें। उदाहरण के Site और Action की जगह अपना लक्ष्य होस्टनाम और ऐक्शन डालें। साइट की आपके वर्कस्पेस में सक्रिय प्रोफ़ाइल होनी चाहिए; उसका होस्टनाम भेजने से प्रोफ़ाइल नहीं बनती। यह reCAPTCHA अनुरोध एक प्रॉक्सी इस्तेमाल करता है और इसे Type या URL की ज़रूरत नहीं है।

package main

import (
    "context"
    "fmt"
    "errors"
    "log"
    "os"
    "time"
    solvethree "solvethree.com/sdk"
)

func main() {
    client, err := solvethree.NewClient(os.Getenv("SOLVETHREE_API_KEY"), nil)
    if err != nil { log.Fatal(err) }
    ctx, cancel := context.WithTimeout(context.Background(), 180*time.Second)
    defer cancel()
    input := solvethree.TaskRequest{Site: "accounts.example.com", Action: "login", Proxy: os.Getenv("SOLVETHREE_PROXY")}
    result, err := client.Solve(ctx, input, solvethree.SolveOptions{})
    if err != nil {
        var failed *solvethree.TaskFailedError
        var api *solvethree.APIError
        var recovery *solvethree.Error
        switch {
        case errors.As(err, &failed):
            log.Printf("Failed task %s: %s", failed.TaskID, failed.ErrorCode)
        case errors.As(err, &recovery):
            log.Printf("Recovery request=%s task=%s", recovery.RequestID, recovery.TaskID)
            if errors.As(err, &api) { log.Printf("HTTP %d; retry delay %s", api.StatusCode, api.RetryAfter) }
            // Save input plus recovery.RequestID. Resume GetTask for a known TaskID;
            // otherwise replay CreateTask with identical inputs and that RequestID.
        }
        return
    }
    fmt.Println("Ready task:", result.ID)
    // Submit result.Solution.Token with its browser identity and original proxy.
}

उदाहरण कॉन्टेक्स्ट की समय-सीमा 180 सेकंड सेट करता है और SDK त्रुटि में रिकवरी ID उपलब्ध होने पर उन्हें लॉग करता है। लॉगिंग स्थायी रिकवरी नहीं है: त्रुटि को हटाने से पहले मूल input, लौटाया गया RequestID और कोई भी TaskID सहेजें।

“तैयार टास्क” का मतलब है कि समाधान उपलब्ध है, यह नहीं कि लक्ष्य ने उसे स्वीकार कर लिया है। SDK आपकी ओर से इसे सबमिट नहीं करता। लौटाई गई ब्राउज़र पहचान और, एक प्रॉक्सी वाले इस उदाहरण में, मूल प्रॉक्सी का इस्तेमाल करके Solution.Token सबमिट करें।

रैप की गई त्रुटियाँ errors.As से और कैंसलेशन errors.Is से जाँचें। ये जाँचें अलग-अलग सवालों के जवाब देती हैं: एक त्रुटि में रिकवरी ID हो सकती हैं, वह HTTP त्रुटि को रैप कर सकती है और फिर भी उसे बाधित ऑपरेशन के रूप में संभालना पड़ सकता है।

उदाहरण अपनी रिकवरी ब्रांच में नेस्टेड APIError की जाँच करता है। अगर आपके एप्लिकेशन को समय-सीमा पूरी होने और स्पष्ट कैंसलेशन में अंतर करना है, तो errors.Is से कैंसलेशन अलग से जाँचें।

Solve टास्क एक बार बनाता है। यह केवल HTTP 429, 502, 503 या 504 वाले अस्थायी पोलिंग रिस्पॉन्स पर दोबारा प्रयास करता है और कॉन्टेक्स्ट की समय-सीमा के भीतर Retry-After का पालन करता है। CreateTask अपना POST कभी अपने-आप दोबारा नहीं भेजता।

1. 1.

   मूल अनुरोध जस का तस रखें

   प्रॉक्सी या कैंडिडेट सूची सहित सभी टास्क इनपुट अनुरोध ID के साथ सहेजें। अनुरोध ID न देने पर CreateTask एक ID जनरेट करता है; रिकवरी त्रुटि में उपलब्ध कराया गया यह जनरेट किया गया मान सहेजें। बाद में ऐसे कॉन्फ़िगरेशन से अनुरोध दोबारा न बनाएँ जो बदल चुका हो सकता है।

2. 2.

   टास्क ID पता हो तो GetTask इस्तेमाल करें

   पुराना कॉन्टेक्स्ट समाप्त या रद्द हो गया हो तो नया कॉन्टेक्स्ट बनाएँ, फिर सहेजे गए TaskID वाला टास्क GetTask से प्राप्त करें। pending या solving स्थिति में इंतज़ार जारी रखें, केवल ready स्थिति में समाधान इस्तेमाल करें और failed पर रुक जाएँ।

3. 3.

   टास्क ID पता न होने पर ही बनाने का अनुरोध दोबारा भेजें

   सहेजे गए मूल TaskRequest में RequestID को रिकवर की गई अनुरोध ID पर सेट करें, फिर उन्हीं इनपुट के साथ CreateTask कॉल करें। वही ID और अनुरोध दोबारा इस्तेमाल करने से मौजूदा टास्क लौटता है। उसी ID का दोबारा इस्तेमाल करते हुए इनपुट बदलने से कॉन्फ़्लिक्ट होता है।

केवल कनेक्शन टाइमआउट होने के कारण नई अनुरोध ID इस्तेमाल न करें। इससे अनिश्चित स्थिति वाले टास्क को रिकवर करने के बजाय नया लॉजिकल टास्क शुरू होता है। पहले पता करें कि मूल टास्क का क्या हुआ; अगर वह विफल हुआ, तो संशोधित अनुरोध की ज़रूरत तय करने से पहले उसकी त्रुटि जाँचें।