349 lines
10 KiB
Go
349 lines
10 KiB
Go
package qiniu
|
|
|
|
import (
|
|
"context"
|
|
"crypto/hmac"
|
|
"crypto/sha1"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"time"
|
|
|
|
"u-desk/internal/oss"
|
|
)
|
|
|
|
// BucketAccessControl 空间访问控制类型
|
|
type BucketAccessControl int
|
|
|
|
const (
|
|
// BucketAccessControlPublic 公开空间 (0)
|
|
BucketAccessControlPublic BucketAccessControl = 0
|
|
// BucketAccessControlPrivate 私有空间 (1)
|
|
BucketAccessControlPrivate BucketAccessControl = 1
|
|
)
|
|
|
|
// String 返回访问控制的字符串表示
|
|
func (a BucketAccessControl) String() string {
|
|
switch a {
|
|
case BucketAccessControlPublic:
|
|
return "公开"
|
|
case BucketAccessControlPrivate:
|
|
return "私有"
|
|
default:
|
|
return "未知"
|
|
}
|
|
}
|
|
|
|
// GetBucketDomains 获取空间绑定的域名列表
|
|
// 根据: https://developer.qiniu.com/kodo/api/3949/get-the-bucket-space-domain
|
|
//
|
|
// 返回:
|
|
// - []string: 域名列表
|
|
// - error: 错误信息
|
|
//
|
|
// 注意：
|
|
// - 返回的域名包括七牛云提供的默认域名和用户绑定的自定义域名
|
|
// - 默认域名格式: <bucket>.<region>.qiniudns.com 或 <bucket>.<region>.clouddn.com
|
|
func (c *Client) GetBucketDomains(ctx context.Context) ([]string, error) {
|
|
// 构建查询参数
|
|
params := url.Values{}
|
|
params.Set("tbl", c.config.Bucket)
|
|
|
|
// 构建 URL
|
|
// 格式: GET /v6/domain/list?tbl=<bucketName>
|
|
apiURL := fmt.Sprintf("%s/v6/domain/list?%s", c.apiAPI, params.Encode())
|
|
|
|
// 创建请求
|
|
req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil)
|
|
if err != nil {
|
|
return nil, oss.NewError("BUCKET_ERROR", "failed to create request", err)
|
|
}
|
|
|
|
// 使用 API 服务的 host 生成认证
|
|
// API 接口使用简单的查询字符串认证
|
|
path := "/v6/domain/list"
|
|
queryString := params.Encode()
|
|
host := "api.qiniu.com"
|
|
authToken := c.generateAuthTokenWithQuery("GET", path, queryString, host, "application/x-www-form-urlencoded", nil)
|
|
|
|
req.Header.Set("Host", host)
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
req.Header.Set("Authorization", authToken)
|
|
|
|
// 发送请求
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, oss.NewError("BUCKET_ERROR", "failed to get bucket domains", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, oss.NewError("BUCKET_ERROR", "failed to read response", err)
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
return nil, oss.NewError("BUCKET_ERROR",
|
|
fmt.Sprintf("get bucket domains failed with status %d: %s", resp.StatusCode, string(body)), nil)
|
|
}
|
|
|
|
// 解析响应（JSON 数组）
|
|
var domains []string
|
|
if err := json.Unmarshal(body, &domains); err != nil {
|
|
return nil, oss.NewError("BUCKET_ERROR", "failed to parse response", err)
|
|
}
|
|
|
|
return domains, nil
|
|
}
|
|
|
|
// GetBucketRegion 查询桶的真实区域
|
|
// API: POST https://uc.qbox.me/v2/buckets → 遍历匹配桶名获取 region
|
|
func (c *Client) GetBucketRegion(ctx context.Context) (string, error) {
|
|
// 使用 UC API 获取所有桶列表（含 region）
|
|
req, err := http.NewRequestWithContext(ctx, "POST", "https://uc.qbox.me/v2/buckets", nil)
|
|
if err != nil {
|
|
return "", oss.NewError("BUCKET_ERROR", "failed to create request", err)
|
|
}
|
|
|
|
path := "/v2/buckets"
|
|
host := "uc.qbox.me"
|
|
authToken := c.generateAuthTokenWithQuery("POST", path, "", host, "application/x-www-form-urlencoded", nil)
|
|
req.Header.Set("Host", host)
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
req.Header.Set("Authorization", authToken)
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return "", oss.NewError("BUCKET_ERROR", "failed to query bucket region", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return "", oss.NewError("BUCKET_ERROR", "failed to read response", err)
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
return "", oss.NewError("BUCKET_ERROR",
|
|
fmt.Sprintf("query bucket region failed with status %d: %s", resp.StatusCode, string(body)), nil)
|
|
}
|
|
|
|
var buckets []struct {
|
|
ID string `json:"id"`
|
|
Region string `json:"region"`
|
|
}
|
|
if err := json.Unmarshal(body, &buckets); err != nil {
|
|
return "", oss.NewError("BUCKET_ERROR", "failed to parse response", err)
|
|
}
|
|
|
|
for _, b := range buckets {
|
|
if b.ID == c.config.Bucket {
|
|
return b.Region, nil
|
|
}
|
|
}
|
|
|
|
return "", oss.NewError("BUCKET_ERROR", fmt.Sprintf("bucket %s not found in account", c.config.Bucket), nil)
|
|
}
|
|
|
|
// SetBucketAccess 设置空间访问权限（公开/私有）
|
|
// 根据: https://developer.qiniu.com/kodo/api/3946/set-bucket-private
|
|
//
|
|
// 参数:
|
|
// - access: BucketAccessControlPublic(公开) 或 BucketAccessControlPrivate(私有)
|
|
//
|
|
// 注意：
|
|
// - 公开空间：文件可通过 URL 直接访问
|
|
// - 私有空间：文件访问需要下载凭证
|
|
// - 修改权限会影响该空间下所有文件的访问方式
|
|
func (c *Client) SetBucketAccess(ctx context.Context, access BucketAccessControl) error {
|
|
// 构建查询参数
|
|
params := url.Values{}
|
|
params.Set("bucket", c.config.Bucket)
|
|
params.Set("private", fmt.Sprintf("%d", access))
|
|
|
|
// 构建 URL
|
|
// 格式: POST /private?bucket=<bucketName>&private=<0|1>
|
|
apiURL := fmt.Sprintf("%s/private?%s", c.apiAPI, params.Encode())
|
|
|
|
// 创建请求
|
|
req, err := http.NewRequestWithContext(ctx, "POST", apiURL, nil)
|
|
if err != nil {
|
|
return oss.NewError("BUCKET_ERROR", "failed to create request", err)
|
|
}
|
|
|
|
// 使用 API 服务的 host 生成认证
|
|
path := "/private"
|
|
queryString := params.Encode()
|
|
host := "api.qiniu.com"
|
|
authToken := c.generateAuthTokenWithQuery("POST", path, queryString, host, "application/x-www-form-urlencoded", nil)
|
|
|
|
req.Header.Set("Host", host)
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
req.Header.Set("Authorization", authToken)
|
|
|
|
// 发送请求
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return oss.NewError("BUCKET_ERROR", "failed to set bucket access", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode == 200 {
|
|
return nil
|
|
}
|
|
|
|
body, _ := io.ReadAll(resp.Body)
|
|
return oss.NewError("BUCKET_ERROR",
|
|
fmt.Sprintf("set bucket access failed with status %d: %s", resp.StatusCode, string(body)), nil)
|
|
}
|
|
|
|
// SetBucketPublic 设置空间为公开空间
|
|
// 便捷方法：将空间设置为公开访问
|
|
func (c *Client) SetBucketPublic(ctx context.Context) error {
|
|
return c.SetBucketAccess(ctx, BucketAccessControlPublic)
|
|
}
|
|
|
|
// SetBucketPrivate 设置空间为私有空间
|
|
// 便捷方法：将空间设置为私有访问
|
|
func (c *Client) SetBucketPrivate(ctx context.Context) error {
|
|
return c.SetBucketAccess(ctx, BucketAccessControlPrivate)
|
|
}
|
|
|
|
// BucketInfo 空间信息
|
|
type BucketInfo struct {
|
|
Name string // 空间名称
|
|
Region string // 区域
|
|
Domains []string // 绑定的域名列表
|
|
IsPrivate bool // 是否为私有空间
|
|
}
|
|
|
|
// GetBucketInfo 获取空间信息
|
|
// 组合方法：获取空间的域名列表和访问权限等信息
|
|
//
|
|
// 注意：
|
|
// - 该方法会调用多个 API 接口获取完整信息
|
|
// - IsPrivate 字段无法通过 API 直接获取，需要通过测试文件访问来确定
|
|
func (c *Client) GetBucketInfo(ctx context.Context) (*BucketInfo, error) {
|
|
// 获取域名列表
|
|
domains, err := c.GetBucketDomains(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 构建基本信息
|
|
info := &BucketInfo{
|
|
Name: c.config.Bucket,
|
|
Region: c.config.Region,
|
|
Domains: domains,
|
|
// IsPrivate 需要通过其他方式确定
|
|
}
|
|
|
|
return info, nil
|
|
}
|
|
|
|
// CheckBucketAccess 检查空间访问权限
|
|
// 通过尝试访问一个不存在的文件来判断空间是否为私有
|
|
//
|
|
// 返回:
|
|
// - bool: true=私有空间, false=公开空间
|
|
// - error: 错误信息
|
|
//
|
|
// 注意：
|
|
// - 该方法会发送一个测试请求来判断空间权限
|
|
// - 如果空间内没有文件，可能无法准确判断
|
|
func (c *Client) CheckBucketAccess(ctx context.Context) (bool, error) {
|
|
// 尝试获取一个不存在的文件的信息
|
|
// 如果是公开空间，会返回明确的"文件不存在"错误
|
|
// 如果是私有空间，会返回认证错误
|
|
testKey := fmt.Sprintf("__qiniu_test_access_check_%d__", time.Now().UnixNano())
|
|
|
|
_, err := c.GetFileInfo(ctx, testKey)
|
|
if err == oss.ErrFileNotFound {
|
|
// 返回文件不存在，说明是公开空间
|
|
return false, nil
|
|
}
|
|
|
|
// 其他错误情况，可能需要根据错误信息判断
|
|
if err != nil {
|
|
// 检查错误信息中是否包含认证相关的内容
|
|
errStr := err.Error()
|
|
if contains(errStr, "permission") || contains(errStr, "unauthorized") || contains(errStr, "token") {
|
|
return true, nil // 私有空间
|
|
}
|
|
}
|
|
|
|
// 默认假设为公开空间
|
|
return false, nil
|
|
}
|
|
|
|
// contains 辅助函数：检查字符串是否包含子串（忽略大小写）
|
|
func contains(str, substr string) bool {
|
|
return len(str) >= len(substr) && (str == substr || len(str) > len(substr) && containsIgnoreCase(str, substr))
|
|
}
|
|
|
|
func containsIgnoreCase(str, substr string) bool {
|
|
// 简化实现，实际使用时可以使用 strings.ToLower
|
|
for i := 0; i <= len(str)-len(substr); i++ {
|
|
match := true
|
|
for j := 0; j < len(substr); j++ {
|
|
c1 := str[i+j]
|
|
c2 := substr[j]
|
|
if c1 >= 'A' && c1 <= 'Z' {
|
|
c1 += 32
|
|
}
|
|
if c2 >= 'A' && c2 <= 'Z' {
|
|
c2 += 32
|
|
}
|
|
if c1 != c2 {
|
|
match = false
|
|
break
|
|
}
|
|
}
|
|
if match {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ListBuckets 列出所有存储桶
|
|
func ListBuckets(accessKey, secretKey string) ([]oss.BucketEntry, error) {
|
|
signingStr := "/buckets\n"
|
|
token := accessKey + ":" + signHmacSha1(secretKey, signingStr)
|
|
|
|
req, _ := http.NewRequest("POST", "https://rs.qbox.me/buckets", nil)
|
|
req.Header.Set("Authorization", "QBox "+token)
|
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("列举存储桶失败: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
body, _ := io.ReadAll(resp.Body)
|
|
return nil, fmt.Errorf("列举存储桶失败: HTTP %d: %s", resp.StatusCode, string(body))
|
|
}
|
|
|
|
var names []string
|
|
if err := json.NewDecoder(resp.Body).Decode(&names); err != nil {
|
|
return nil, fmt.Errorf("解析存储桶列表失败: %w", err)
|
|
}
|
|
|
|
entries := make([]oss.BucketEntry, len(names))
|
|
for i, name := range names {
|
|
entries[i] = oss.BucketEntry{Name: name}
|
|
}
|
|
return entries, nil
|
|
}
|
|
|
|
func signHmacSha1(secretKey, data string) string {
|
|
mac := hmac.New(sha1.New, []byte(secretKey))
|
|
mac.Write([]byte(data))
|
|
return base64.URLEncoding.EncodeToString(mac.Sum(nil))
|
|
}
|