125 lines
2.8 KiB
Go
125 lines
2.8 KiB
Go
package storage
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/url"
|
|
"strings"
|
|
)
|
|
|
|
// StorageURL represents a parsed storage URL.
|
|
type StorageURL struct {
|
|
Scheme string // "s3", "file", or "rclone"
|
|
Bucket string // S3 bucket name (empty for file/rclone)
|
|
Prefix string // Path within bucket or filesystem base path
|
|
Endpoint string // S3 endpoint (optional, default AWS)
|
|
Region string // S3 region (optional)
|
|
UseSSL bool // Use HTTPS for S3 (default true)
|
|
RcloneRemote string // rclone remote name (for rclone:// URLs)
|
|
}
|
|
|
|
// ParseStorageURL parses a storage URL string.
|
|
// Supported formats:
|
|
// - s3://bucket/prefix?endpoint=host®ion=us-east-1&ssl=true
|
|
// - file:///absolute/path/to/backup
|
|
// - rclone://remote/path/to/backups
|
|
func ParseStorageURL(rawURL string) (*StorageURL, error) {
|
|
if rawURL == "" {
|
|
return nil, errors.New("storage URL is empty")
|
|
}
|
|
|
|
// Handle file:// URLs
|
|
if after, ok := strings.CutPrefix(rawURL, "file://"); ok {
|
|
path := after
|
|
if path == "" {
|
|
return nil, errors.New("file URL path is empty")
|
|
}
|
|
|
|
return &StorageURL{
|
|
Scheme: "file",
|
|
Prefix: path,
|
|
}, nil
|
|
}
|
|
|
|
// Handle s3:// URLs
|
|
if strings.HasPrefix(rawURL, "s3://") {
|
|
u, err := url.Parse(rawURL)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid URL: %w", err)
|
|
}
|
|
|
|
bucket := u.Host
|
|
if bucket == "" {
|
|
return nil, errors.New("s3 URL missing bucket name")
|
|
}
|
|
|
|
prefix := strings.TrimPrefix(u.Path, "/")
|
|
|
|
query := u.Query()
|
|
|
|
useSSL := true
|
|
if query.Get("ssl") == "false" {
|
|
useSSL = false
|
|
}
|
|
|
|
return &StorageURL{
|
|
Scheme: "s3",
|
|
Bucket: bucket,
|
|
Prefix: prefix,
|
|
Endpoint: query.Get("endpoint"),
|
|
Region: query.Get("region"),
|
|
UseSSL: useSSL,
|
|
}, nil
|
|
}
|
|
|
|
// Handle rclone:// URLs
|
|
if strings.HasPrefix(rawURL, "rclone://") {
|
|
u, err := url.Parse(rawURL)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("invalid URL: %w", err)
|
|
}
|
|
|
|
remote := u.Host
|
|
if remote == "" {
|
|
return nil, errors.New("rclone URL missing remote name")
|
|
}
|
|
|
|
path := strings.TrimPrefix(u.Path, "/")
|
|
|
|
return &StorageURL{
|
|
Scheme: "rclone",
|
|
Prefix: path,
|
|
RcloneRemote: remote,
|
|
}, nil
|
|
}
|
|
|
|
return nil, errors.New("unsupported URL scheme: must start with s3://, file://, or rclone://")
|
|
}
|
|
|
|
// String returns a human-readable representation of the storage URL.
|
|
func (u *StorageURL) String() string {
|
|
switch u.Scheme {
|
|
case "file":
|
|
return "file://" + u.Prefix
|
|
case "s3":
|
|
endpoint := u.Endpoint
|
|
if endpoint == "" {
|
|
endpoint = "s3.amazonaws.com"
|
|
}
|
|
|
|
if u.Prefix != "" {
|
|
return fmt.Sprintf("s3://%s/%s (endpoint: %s)", u.Bucket, u.Prefix, endpoint)
|
|
}
|
|
|
|
return fmt.Sprintf("s3://%s (endpoint: %s)", u.Bucket, endpoint)
|
|
case "rclone":
|
|
if u.Prefix != "" {
|
|
return fmt.Sprintf("rclone://%s/%s", u.RcloneRemote, u.Prefix)
|
|
}
|
|
|
|
return "rclone://" + u.RcloneRemote
|
|
default:
|
|
return u.Scheme + "://?"
|
|
}
|
|
}
|