गोलंग में HTTP हैंडलर्स के लेखन को सरल बनाएं

आने वाले HTTP अनुरोध को संसाधित करते समय, बड़ी संख्या में क्रियाओं की आवश्यकता होती है, जैसे:

• एक आने वाली HTTP अनुरोध लॉगिंग
• HTTP विधि की मान्यता
• प्रमाणीकरण (मूल, एमएस विज्ञापन, ...)
• टोकन सत्यापन (यदि आवश्यक हो)
• आने वाले अनुरोध के शरीर को पढ़ना
• आने वाले अनुरोध के हेडर को पढ़ना
• वास्तव में अनुरोध को संसाधित करना और प्रतिक्रिया उत्पन्न करना
• HSTS सख्त-परिवहन-सुरक्षा स्थापित करें
• आउटगोइंग प्रतिक्रिया के लिए सामग्री-प्रकार सेट करना
• जावक HTTP प्रतिक्रिया लॉगिंग
• आउटगोइंग प्रतिक्रिया का रिकॉर्ड हेडर
• रिकॉर्ड आउटगोइंग रिस्पांस बॉडी
• हैंडलिंग और लॉगिंग में त्रुटि
• एक संभव आतंक के बाद वसूली के लिए डिफर रिकवरी प्रोसेसिंग

इन कार्यों में से अधिकांश विशिष्ट हैं और अनुरोध के प्रकार और इसके प्रसंस्करण पर निर्भर नहीं हैं।
उत्पादक कार्रवाई के लिए, प्रत्येक कार्रवाई के लिए त्रुटि हैंडलिंग और लॉगिंग प्रदान करना आवश्यक है।

हर HTTP हैंडलर में यह सब दोहराना बेहद अक्षम है।

यहां तक ​​कि अगर आप सभी कोड को अलग-अलग उपखंडों में रखते हैं, तो भी आपको अनुरोध के वास्तविक प्रसंस्करण और प्रतिक्रिया के गठन को ध्यान में रखे बिना प्रत्येक HTTP हैंडलर के लिए कोड की लगभग 80-100 पंक्तियां मिलती हैं ।

निम्नलिखित का वर्णन करता है कि मैं कोड जनरेटर और तीसरे पक्ष के पुस्तकालयों के उपयोग के बिना गोलंग में HTTP हैंडलर्स के लेखन को सरल बनाने के लिए उपयोग करता हूं।

backend Golang

.
, , — , - .

HTTP

UML HTTP EchoHandler.

, , :

• defer . UML — RecoverWrap.func1, .
• . HTTP handler. UML Process — .
• HTTP handler. UML EchoHandler.func1 — .

.

HTTP EchoHandler, "" .

, EchoHandler, ( RecoverWrap), EchoHandler.

router.HandleFunc("/echo", service.RecoverWrap(http.HandlerFunc(service.EchoHandler))).Methods("GET")

RecoverWrap .
defer func() EchoHandler.

func (s *Service) RecoverWrap(handlerFunc http.HandlerFunc) http.HandlerFunc {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        //     
        defer func() {
            var myerr error
            r := recover()
            if r != nil {
                msg := "HTTP Handler recover from panic"
                switch t := r.(type) {
                case string:
                    myerr = myerror.New("8888", msg, t)
                case error:
                    myerr = myerror.WithCause("8888", msg, t)
                default:
                    myerr = myerror.New("8888", msg)
                }
                //      HTTP
                s.processError(myerr, w, http.StatusInternalServerError, 0)
            }
        }()

        //  
        if handlerFunc != nil {
            handlerFunc(w, r)
        }
    })
}

, EchoHandler. , HTTP Process .

func (s *Service) EchoHandler(w http.ResponseWriter, r *http.Request) {
    //    HTTP  
    _ = s.Process("POST", w, r, func(requestBuf []byte, reqID uint64) ([]byte, Header, int, error) {
        header := Header{} //  

        //            
        for key := range r.Header {
            header[key] = r.Header.Get(key)
        }
        //      ,     
        return requestBuf, header, http.StatusOK, nil
    })
}

HTTP Process. :

• method string — HTTP HTTP
• w http.ResponseWriter, r *http.Request —
• fn func (requestBuf [] बाइट, reqID uint64) ([] बाइट, हैडर, इंट, एरर) - खुद प्रोसेसिंग फंक्शन, यह एक इनकमिंग रिक्वेस्ट बफर और एक यूनिक HTTP रिक्वेस्ट नंबर (लॉगिंग के लिए), तैयार आउटगोइंग रिस्पॉन्स बफर देता है , आउटगोइंग प्रतिक्रिया, HTTP स्थिति और त्रुटि के हेडर।

func (s *Service) Process(method string, w http.ResponseWriter, r *http.Request, fn func(requestBuf []byte, reqID uint64) ([]byte, Header, int, error)) error {
    var myerr error

    //    HTTP 
    reqID := GetNextRequestID()

    //   HTTP 
    if s.logger != nil {
        _ = s.logger.LogHTTPInRequest(s.tx, r, reqID) //   HTTP ,   ,    
        mylog.PrintfDebugMsg("Logging HTTP in request: reqID", reqID)
    }

    //   
    mylog.PrintfDebugMsg("Check allowed HTTP method: reqID, request.Method, method", reqID, r.Method, method)
    if r.Method != method {
        myerr = myerror.New("8000", "HTTP method is not allowed: reqID, request.Method, method", reqID, r.Method, method)
        mylog.PrintfErrorInfo(myerr)
        return myerr
    }

    //       JWT ,       
    mylog.PrintfDebugMsg("Check authentication method: reqID, AuthType", reqID, s.cfg.AuthType)
    if (s.cfg.AuthType == "INTERNAL" || s.cfg.AuthType == "MSAD") && !s.cfg.UseJWT {
        mylog.PrintfDebugMsg("JWT is of. Need Authentication: reqID", reqID)

        //    HTTP Basic Authentication
        username, password, ok := r.BasicAuth()
        if !ok {
            myerr := myerror.New("8004", "Header 'Authorization' is not set")
            mylog.PrintfErrorInfo(myerr)
            return myerr
        }
        mylog.PrintfDebugMsg("Get Authorization header: username", username)

        //  
        if myerr = s.checkAuthentication(username, password); myerr != nil {
            mylog.PrintfErrorInfo(myerr)
            return myerr
        }
    }

    //   JWT -  
    if s.cfg.UseJWT {
        mylog.PrintfDebugMsg("JWT is on. Check JSON web token: reqID", reqID)

        //  token  requests cookies
        cookie, err := r.Cookie("token")
        if err != nil {
            myerr := myerror.WithCause("8005", "JWT token does not present in Cookie. You have to authorize first.", err)
            mylog.PrintfErrorInfo(myerr)
            return myerr
        }

        //  JWT  token
        if myerr = myjwt.CheckJWTFromCookie(cookie, s.cfg.JwtKey); myerr != nil {
            mylog.PrintfErrorInfo(myerr)
            return myerr
        }
    }

    //   
    mylog.PrintfDebugMsg("Reading request body: reqID", reqID)
    requestBuf, err := ioutil.ReadAll(r.Body)
    if err != nil {
        myerr = myerror.WithCause("8001", "Failed to read HTTP body: reqID", err, reqID)
        mylog.PrintfErrorInfo(myerr)
        return myerr
    }
    mylog.PrintfDebugMsg("Read request body: reqID, len(body)", reqID, len(requestBuf))

    //  
    mylog.PrintfDebugMsg("Calling external function handler: reqID, function", reqID, fn)
    responseBuf, header, status, myerr := fn(requestBuf, reqID)
    if myerr != nil {
        mylog.PrintfErrorInfo(myerr)
        return myerr
    }

    // use HSTS Strict-Transport-Security
    if s.cfg.UseHSTS {
        w.Header().Add("Strict-Transport-Security", "max-age=63072000; includeSubDomains")
    }

    //    
    if s.logger != nil {
        mylog.PrintfDebugMsg("Logging HTTP out response: reqID", reqID)
        _ = s.logger.LogHTTPOutResponse(s.tx, header, responseBuf, status, reqID) //   HTTP ,   ,    
    }

    //   
    mylog.PrintfDebugMsg("Set HTTP response headers: reqID", reqID)
    if header != nil {
        for key, h := range header {
            w.Header().Set(key, h)
        }
    }

    //  HTTP  
    mylog.PrintfDebugMsg("Set HTTP response status: reqID, Status", reqID, http.StatusText(status))
    w.WriteHeader(status)

    //   
    if responseBuf != nil && len(responseBuf) > 0 {
        mylog.PrintfDebugMsg("Writing HTTP response body: reqID, len(body)", reqID, len(responseBuf))
        respWrittenLen, err := w.Write(responseBuf)
        if err != nil {
            myerr = myerror.WithCause("8002", "Failed to write HTTP repsonse: reqID", err)
            mylog.PrintfErrorInfo(myerr)
            return myerr
        }
        mylog.PrintfDebugMsg("Written HTTP response: reqID, len(body)", reqID, respWrittenLen)
    }

    return nil
}