111 lines
2.4 KiB
Go
111 lines
2.4 KiB
Go
package util
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"govd/models"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"os"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
var (
|
|
edgeProxyClient *EdgeProxyClient
|
|
edgeProxyClientOnce sync.Once
|
|
)
|
|
|
|
type EdgeProxyClient struct {
|
|
*http.Client
|
|
}
|
|
|
|
func GetEdgeProxyClient() *EdgeProxyClient {
|
|
edgeProxyClientOnce.Do(func() {
|
|
edgeProxyClient = &EdgeProxyClient{
|
|
Client: &http.Client{
|
|
Transport: baseTransport,
|
|
Timeout: 60 * time.Second,
|
|
},
|
|
}
|
|
})
|
|
return edgeProxyClient
|
|
}
|
|
|
|
func (c *EdgeProxyClient) Do(req *http.Request) (*http.Response, error) {
|
|
proxyURL := os.Getenv("EDGE_PROXY_URL")
|
|
if proxyURL == "" {
|
|
return nil, fmt.Errorf("EDGE_PROXY_URL environment variable is not set")
|
|
}
|
|
targetURL := req.URL.String()
|
|
encodedURL := url.QueryEscape(targetURL)
|
|
proxyURLWithParam := proxyURL + "?url=" + encodedURL
|
|
|
|
var bodyBytes []byte
|
|
var err error
|
|
|
|
if req.Body != nil {
|
|
bodyBytes, err = io.ReadAll(req.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading request body: %w", err)
|
|
}
|
|
req.Body.Close()
|
|
req.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
|
|
}
|
|
|
|
proxyReq, err := http.NewRequest(
|
|
req.Method,
|
|
proxyURLWithParam,
|
|
bytes.NewBuffer(bodyBytes),
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error creating proxy request: %w", err)
|
|
}
|
|
|
|
for name, values := range req.Header {
|
|
for _, value := range values {
|
|
proxyReq.Header.Add(name, value)
|
|
}
|
|
}
|
|
|
|
proxyResp, err := c.Client.Do(proxyReq)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("proxy request failed: %w", err)
|
|
}
|
|
defer proxyResp.Body.Close()
|
|
|
|
body, err := io.ReadAll(proxyResp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading proxy response: %w", err)
|
|
}
|
|
|
|
var response models.ProxyResponse
|
|
if err := json.Unmarshal(body, &response); err != nil {
|
|
return nil, fmt.Errorf("error parsing proxy response: %w", err)
|
|
}
|
|
|
|
resp := &http.Response{
|
|
StatusCode: response.StatusCode,
|
|
Status: fmt.Sprintf("%d %s", response.StatusCode, http.StatusText(response.StatusCode)),
|
|
Body: io.NopCloser(bytes.NewBufferString(response.Text)),
|
|
Header: make(http.Header),
|
|
Request: req,
|
|
}
|
|
parsedResponseURL, err := url.Parse(response.URL)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error parsing response URL: %w", err)
|
|
}
|
|
resp.Request.URL = parsedResponseURL
|
|
|
|
for name, value := range response.Headers {
|
|
resp.Header.Set(name, value)
|
|
}
|
|
|
|
for _, cookie := range response.Cookies {
|
|
resp.Header.Add("Set-Cookie", cookie)
|
|
}
|
|
|
|
return resp, nil
|
|
}
|