112 lines
3.1 KiB
Go
112 lines
3.1 KiB
Go
package plugins
|
|
|
|
import (
|
|
"fmt"
|
|
"net/url"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/valyala/fasthttp"
|
|
)
|
|
|
|
var (
|
|
ErrPluginNotFound = fmt.Errorf("plugin not found")
|
|
)
|
|
|
|
// pluginDownloadClient is a fasthttp client with a larger read buffer to handle
|
|
// responses with large headers.
|
|
var pluginDownloadClient = &fasthttp.Client{
|
|
ReadBufferSize: 64 * 1024, // 64KB, matches the bifrost HTTP server setting
|
|
}
|
|
|
|
// DownloadPlugin downloads a plugin from a URL and returns the local file path
|
|
func DownloadPlugin(pluginURL string, extension string) (string, error) {
|
|
req := fasthttp.AcquireRequest()
|
|
defer fasthttp.ReleaseRequest(req)
|
|
response := fasthttp.AcquireResponse()
|
|
defer fasthttp.ReleaseResponse(response)
|
|
|
|
req.Header.SetMethod(fasthttp.MethodGet)
|
|
req.Header.Set("Accept", "application/octet-stream")
|
|
req.Header.Set("Accept-Encoding", "gzip")
|
|
req.Header.Set("Accept-Language", "en-US,en;q=0.9")
|
|
|
|
const maxRedirects = 5
|
|
currentURL := pluginURL
|
|
for i := 0; i <= maxRedirects; i++ {
|
|
req.SetRequestURI(currentURL)
|
|
if i > 0 {
|
|
response.Reset()
|
|
}
|
|
|
|
if err := pluginDownloadClient.DoTimeout(req, response, 120*time.Second); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
statusCode := response.StatusCode()
|
|
if statusCode == fasthttp.StatusOK {
|
|
break
|
|
}
|
|
if statusCode >= 300 && statusCode < 400 {
|
|
if i == maxRedirects {
|
|
return "", fmt.Errorf("too many redirects downloading plugin")
|
|
}
|
|
location := string(response.Header.Peek("Location"))
|
|
if location == "" {
|
|
return "", fmt.Errorf("redirect response missing Location header: HTTP %d", statusCode)
|
|
}
|
|
loc, err := url.Parse(location)
|
|
if err != nil {
|
|
return "", fmt.Errorf("invalid Location header %q: %w", location, err)
|
|
}
|
|
base, err := url.Parse(currentURL)
|
|
if err != nil {
|
|
return "", fmt.Errorf("invalid request URL %q: %w", currentURL, err)
|
|
}
|
|
currentURL = base.ResolveReference(loc).String()
|
|
continue
|
|
}
|
|
return "", fmt.Errorf("failed to download plugin: HTTP %d", statusCode)
|
|
}
|
|
|
|
// Decompress the response body if it was gzip/deflate compressed
|
|
// BodyUncompressed handles both gzip and deflate encodings based on Content-Encoding header
|
|
body, err := response.BodyUncompressed()
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to decompress response body: %w", err)
|
|
}
|
|
|
|
// Create a unique temporary file for the plugin
|
|
tempFile, err := os.CreateTemp(os.TempDir(), "bifrost-plugin-*"+extension)
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to create temporary file: %w", err)
|
|
}
|
|
tempPath := tempFile.Name()
|
|
|
|
// Write the downloaded body to the temporary file
|
|
_, err = tempFile.Write(body)
|
|
if err != nil {
|
|
tempFile.Close()
|
|
os.Remove(tempPath)
|
|
return "", fmt.Errorf("failed to write plugin to temporary file: %w", err)
|
|
}
|
|
|
|
// Close the file
|
|
err = tempFile.Close()
|
|
if err != nil {
|
|
os.Remove(tempPath)
|
|
return "", fmt.Errorf("failed to close temporary file: %w", err)
|
|
}
|
|
|
|
// Set file permissions to be executable (for .so files)
|
|
if extension == ".so" {
|
|
err = os.Chmod(tempPath, 0755)
|
|
if err != nil {
|
|
os.Remove(tempPath)
|
|
return "", fmt.Errorf("failed to set executable permissions on plugin: %w", err)
|
|
}
|
|
}
|
|
|
|
return tempPath, nil
|
|
}
|