Documentation ¶
Index ¶
- Constants
- type Client
- func (c *Client) ContinueUploadingSliceData(bucket, dstPath string, dataSlice []byte, session string, offset int64) (*UploadSliceResponse, error)
- func (c *Client) CreateFolder(bucket, path, bizAttr string) (*CreateFolderResponse, error)
- func (c *Client) CreateFolderAsync(bucket, path, bizAttr string) <-chan *CreateFolderAsyncResponse
- func (c *Client) CreateFolderWithCallback(bucket, path, bizAttr string, callback func(*CreateFolderResponse, error))
- func (c *Client) DeleteFile(bucket, path string) (*DeleteFileResponse, error)
- func (c *Client) DeleteFileAsync(bucket, path string) <-chan *DeleteFileAsyncResponse
- func (c *Client) DeleteFileWithCallback(bucket, path string, callback func(*DeleteFileResponse, error))
- func (c *Client) DeleteFolder(bucket, path string) (*DeleteFolderResponse, error)
- func (c *Client) DeleteFolderAsync(bucket, path string) <-chan *DeleteFolderAsyncResponse
- func (c *Client) DeleteFolderWithCallback(bucket, path string, callback func(*DeleteFolderResponse, error))
- func (c Client) IsTimeout(err error) bool
- func (c *Client) ListFolder(bucket, path, context string, pattern ListPattern, num int, order ListOrder) (*ListFolderResponse, error)
- func (c *Client) ListFolderAsync(bucket, path, context string, pattern ListPattern, num int, order ListOrder) <-chan *ListFolderAsyncResponse
- func (c *Client) ListFolderWithCallback(bucket, path, context string, pattern ListPattern, num int, order ListOrder, ...)
- func (c *Client) PrefixSearch(bucket, path, prefix, context string, pattern ListPattern, num int, ...) (*ListFolderResponse, error)
- func (c *Client) PrefixSearchAsync(bucket, path, prefix, context string, pattern ListPattern, num int, ...) <-chan *ListFolderAsyncResponse
- func (c *Client) PrefixSearchWithCallback(bucket, path, prefix, context string, pattern ListPattern, num int, ...)
- func (c *Client) PrepareToUploadSlice(bucket, dstPath, srcPath, bizAttr, session string, sliceSize int64) (*UploadSliceResponse, error)
- func (c *Client) SetTimeout(timeout time.Duration)
- func (c *Client) StatFile(bucket, path string) (*StatFileResponse, error)
- func (c *Client) StatFileAsync(bucket, path string) <-chan *StatFileAsyncResponse
- func (c *Client) StatFileWithCallback(bucket, path string, callback func(*StatFileResponse, error))
- func (c *Client) StatFolder(bucket, path string) (*StatFolderResponse, error)
- func (c *Client) StatFolderAsync(bucket, path string) <-chan *StatFolderAsyncResponse
- func (c *Client) StatFolderWithCallback(bucket, path string, callback func(*StatFolderResponse, error))
- func (c *Client) UpdateFile(bucket, path, bizAttr string) (*UpdateFileResponse, error)
- func (c *Client) UpdateFileAsync(bucket, path, bizAttr string) <-chan *UpdateFileAsyncResponse
- func (c *Client) UpdateFileWithCallback(bucket, path, bizAttr string, callback func(*UpdateFileResponse, error))
- func (c *Client) UpdateFolder(bucket, path, bizAttr string) (*UpdateFolderResponse, error)
- func (c *Client) UpdateFolderAsync(bucket, path, bizAttr string) <-chan *UpdateFolderAsyncResponse
- func (c *Client) UpdateFolderWithCallback(bucket, path, bizAttr string, callback func(*UpdateFolderResponse, error))
- func (c *Client) UploadChunk(bucket, dstPath string, chunk []byte, bizAttr string) (*UploadFileResponse, error)
- func (c *Client) UploadChunkAsync(bucket, dstPath string, chunk []byte, bizAttr string) <-chan *UploadFileAsyncResponse
- func (c *Client) UploadChunkWithCallback(bucket, dstPath string, chunk []byte, bizAttr string, ...)
- func (c *Client) UploadFile(bucket, dstPath, srcPath, bizAttr string) (*UploadFileResponse, error)
- func (c *Client) UploadFileAsync(bucket, dstPath, srcPath, bizAttr string) <-chan *UploadFileAsyncResponse
- func (c *Client) UploadFileWithCallback(bucket, dstPath, srcPath, bizAttr string, ...)
- func (c *Client) UploadSlice(bucket, dstPath, srcPath, bizAttr, session string, sliceSize int64) (*UploadSliceResponse, error)
- func (c *Client) UploadSliceAsync(bucket, dstPath, srcPath, bizAttr, session string, sliceSize int64) <-chan *UploadSliceAsyncResponse
- func (c *Client) UploadSliceWithCallback(bucket, dstPath, srcPath, bizAttr, session string, sliceSize int64, ...)
- type CreateFolderAsyncResponse
- type CreateFolderRequest
- type CreateFolderResponse
- type DeleteFileAsyncResponse
- type DeleteFileRequest
- type DeleteFileResponse
- type DeleteFolderAsyncResponse
- type DeleteFolderRequest
- type DeleteFolderResponse
- type ListFolderAsyncResponse
- type ListFolderRequest
- type ListFolderResponse
- type ListOrder
- type ListPattern
- type PrepareToUploadSliceRequest
- type Request
- type Response
- type StatFileAsyncResponse
- type StatFileRequest
- type StatFileResponse
- type StatFolderAsyncResponse
- type StatFolderRequest
- type StatFolderResponse
- type UpdateFileAsyncResponse
- type UpdateFileRequest
- type UpdateFileResponse
- type UpdateFolderAsyncResponse
- type UpdateFolderRequest
- type UpdateFolderResponse
- type UploadFileAsyncResponse
- type UploadFileRequest
- type UploadFileResponse
- type UploadSliceAsyncResponse
- type UploadSliceRequest
- type UploadSliceResponse
Constants ¶
const ENDPOINT = "http://web.file.myqcloud.com/files/v1/"
const EXPIRES = 60 * 5
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Client ¶
type Client struct { AppId string // 项目 ID SecretId string // 项目 Secret ID SecretKey string // 项目 Secret Key Timeout time.Duration // 客户端超时时长 }
腾讯云 COS API 客户端
func (*Client) ContinueUploadingSliceData ¶
func (c *Client) ContinueUploadingSliceData(bucket, dstPath string, dataSlice []byte, session string, offset int64) (*UploadSliceResponse, error)
大文件分片上传(后续上传)
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 dataSlice: 本地文件路径 session: 唯一标识此文件传输过程的id, 由后台下发, 调用方透传 offset: 本次分片位移
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.ContinueUploadingSliceData("cosdemo", "/hello/bigfile.bin", []byte("data.bin"), "c0bd94d0-3956-4664-b99f-2658eef8e5f5+CpcFEtEHAA==", 1045248) if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nSession:", res.Session, "\nOffset:", res.Offset, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) CreateFolder ¶
func (c *Client) CreateFolder(bucket, path, bizAttr string) (*CreateFolderResponse, error)
创建目录
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.CreateFolder("cosdemo", "/hello", "hello") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nCtime:", res.Data.Ctime, "\nResource Path:", res.Data.ResourcePath)
func (*Client) CreateFolderAsync ¶
func (c *Client) CreateFolderAsync(bucket, path, bizAttr string) <-chan *CreateFolderAsyncResponse
创建目录异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.CreateFolderAsync("cosdemo", "/hello", "hello") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nCtime:", res.Data.Ctime, "\nResource Path:", res.Data.ResourcePath)
func (*Client) CreateFolderWithCallback ¶
func (c *Client) CreateFolderWithCallback(bucket, path, bizAttr string, callback func(*CreateFolderResponse, error))
基于回调函数的目录创建接口, 调用该函数可立即返回, 目录创建完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.CreateFolderWithCallback("cosdemo", "/hello123", "hello", func(res *cos.CreateFolderResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nCtime:", res.Data.Ctime, "\nResource Path:", res.Data.ResourcePath) }) wg.Wait()
func (*Client) DeleteFile ¶
func (c *Client) DeleteFile(bucket, path string) (*DeleteFileResponse, error)
删除文件
bucket: Bucket 名称 path: 文件路径
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.DeleteFile("cosdemo", "/hello/new.txt") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message)
func (*Client) DeleteFileAsync ¶
func (c *Client) DeleteFileAsync(bucket, path string) <-chan *DeleteFileAsyncResponse
删除文件异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 文件路径
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.DeleteFile("cosdemo", "/hello/new.txt") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message)
func (*Client) DeleteFileWithCallback ¶
func (c *Client) DeleteFileWithCallback(bucket, path string, callback func(*DeleteFileResponse, error))
基于回调函数的文件删除接口, 调用该函数可立即返回, 文件删除完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.DeleteFileWithCallback("cosdemo", "/hello123/new.txt", func(res *cos.DeleteFileResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message) }) wg.Wait()
func (*Client) DeleteFolder ¶
func (c *Client) DeleteFolder(bucket, path string) (*DeleteFolderResponse, error)
删除目录
bucket: Bucket 名称 path: 目录路径
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.DeleteFolder("cosdemo", "/hello") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message)
func (*Client) DeleteFolderAsync ¶
func (c *Client) DeleteFolderAsync(bucket, path string) <-chan *DeleteFolderAsyncResponse
删除目录异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 目录路径
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.DeleteFolderAsync("cosdemo", "/hello") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message)
func (*Client) DeleteFolderWithCallback ¶
func (c *Client) DeleteFolderWithCallback(bucket, path string, callback func(*DeleteFolderResponse, error))
基于回调函数的目录删除接口, 调用该函数可立即返回, 目录删除完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.DeleteFolderWithCallback("cosdemo", "/hello123", func(res *cos.DeleteFolderResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message) }) wg.Wait()
func (*Client) ListFolder ¶
func (c *Client) ListFolder(bucket, path, context string, pattern ListPattern, num int, order ListOrder) (*ListFolderResponse, error)
列举目录和文件
bucket: Bucket 名称 path: 目录路径 context: Context 用于翻页, 需要往前/往后翻页需透传回来 pattern: 目录列举模式, 可选值为 Both(列举目录和文件), DirectoryOnly(仅列举目录), FileOnly(仅列举文件) num: 本次拉取的目录和文件总数 order: 目录列举排序规则, 可选值为 Asc(正序), Desc(反序)
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.ListFolder("cosdemo", "/hello", "", cos.Both, 100, cos.Asc) if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nContext:", res.Data.Context, "\nHasMore:", res.Data.HasMore, "\nDirCount:", res.Data.DirCount, "\nFileCount:", res.Data.FileCount, ) fmt.Println("*************************************") for _, info := range res.Data.Infos { fmt.Println("Name:", info.Name, "\nBizAttr:", info.BizAttr, "\nFileSize:", info.FileSize, "\nFileLen:", info.FileLen, "\nSha:", info.Sha, "\nCtime:", info.Ctime, "\nMtime:", info.Mtime, "\nAccess URL:", info.AccessUrl, ) fmt.Println("*************************************") }
func (*Client) ListFolderAsync ¶
func (c *Client) ListFolderAsync(bucket, path, context string, pattern ListPattern, num int, order ListOrder) <-chan *ListFolderAsyncResponse
列举目录和文件异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 目录路径 context: Context 用于翻页, 需要往前/往后翻页需透传回来 pattern: 目录列举模式, 可选值为 Both(列举目录和文件), DirectoryOnly(仅列举目录), FileOnly(仅列举文件) num: 本次拉取的目录和文件总数 order: 目录列举排序规则, 可选值为 Asc(正序), Desc(反序)
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.ListFolderAsync("cosdemo", "/hello", "", cos.Both, 100, cos.Asc) // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nContext:", res.Data.Context, "\nHasMore:", res.Data.HasMore, "\nDirCount:", res.Data.DirCount, "\nFileCount:", res.Data.FileCount, ) fmt.Println("*************************************") for _, info := range res.Data.Infos { fmt.Println("Name:", info.Name, "\nBizAttr:", info.BizAttr, "\nFileSize:", info.FileSize, "\nFileLen:", info.FileLen, "\nSha:", info.Sha, "\nCtime:", info.Ctime, "\nMtime:", info.Mtime, "\nAccess URL:", info.AccessUrl, ) fmt.Println("*************************************") }
func (*Client) ListFolderWithCallback ¶
func (c *Client) ListFolderWithCallback(bucket, path, context string, pattern ListPattern, num int, order ListOrder, callback func(*ListFolderResponse, error))
基于回调函数的前缀搜索目录和文件接口, 调用该函数可立即返回, 搜索完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径 context: Context 用于翻页, 需要往前/往后翻页需透传回来 pattern: 目录列举模式, 可选值为 Both(列举目录和文件), DirectoryOnly(仅列举目录), FileOnly(仅列举文件) num: 本次拉取的目录和文件总数 order: 目录列举排序规则, 可选值为 Asc(正序), Desc(反序)
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.ListFolderWithCallback("cosdemo", "/hello", "", cos.Both, 100, cos.Asc, func(res *cos.ListFolderResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nContext:", res.Data.Context, "\nHasMore:", res.Data.HasMore, "\nDirCount:", res.Data.DirCount, "\nFileCount:", res.Data.FileCount, ) fmt.Println("*************************************") for _, info := range res.Data.Infos { fmt.Println("Name:", info.Name, "\nBizAttr:", info.BizAttr, "\nFileSize:", info.FileSize, "\nFileLen:", info.FileLen, "\nSha:", info.Sha, "\nCtime:", info.Ctime, "\nMtime:", info.Mtime, "\nAccess URL:", info.AccessUrl, ) fmt.Println("*************************************") } }) wg.Wait()
func (*Client) PrefixSearch ¶
func (c *Client) PrefixSearch(bucket, path, prefix, context string, pattern ListPattern, num int, order ListOrder) (*ListFolderResponse, error)
前缀搜索目录和文件
bucket: Bucket 名称 path: 目录路径 prefix: 搜索前缀 context: Context 用于翻页, 需要往前/往后翻页需透传回来 pattern: 目录列举模式, 可选值为 Both(列举目录和文件), DirectoryOnly(仅列举目录), FileOnly(仅列举文件) num: 本次拉取的目录和文件总数 order: 目录列举排序规则, 可选值为 Asc(正序), Desc(反序)
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.PrefixSearch("cosdemo", "/hello", "A", "", cos.Both, 100, cos.Asc) if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nContext:", res.Data.Context, "\nHasMore:", res.Data.HasMore, "\nDirCount:", res.Data.DirCount, "\nFileCount:", res.Data.FileCount, ) fmt.Println("*************************************") for _, info := range res.Data.Infos { fmt.Println("Name:", info.Name, "\nBizAttr:", info.BizAttr, "\nFileSize:", info.FileSize, "\nFileLen:", info.FileLen, "\nSha:", info.Sha, "\nCtime:", info.Ctime, "\nMtime:", info.Mtime, "\nAccess URL:", info.AccessUrl, ) fmt.Println("*************************************") }
func (*Client) PrefixSearchAsync ¶
func (c *Client) PrefixSearchAsync(bucket, path, prefix, context string, pattern ListPattern, num int, order ListOrder) <-chan *ListFolderAsyncResponse
前缀搜索目录和文件异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 目录路径 prefix: 搜索前缀 context: Context 用于翻页, 需要往前/往后翻页需透传回来 pattern: 目录列举模式, 可选值为 Both(列举目录和文件), DirectoryOnly(仅列举目录), FileOnly(仅列举文件) num: 本次拉取的目录和文件总数 order: 目录列举排序规则, 可选值为 Asc(正序), Desc(反序)
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.PrefixSearchAsync("cosdemo", "/hello", "A", "", cos.Both, 100, cos.Asc) // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nContext:", res.Data.Context, "\nHasMore:", res.Data.HasMore, "\nDirCount:", res.Data.DirCount, "\nFileCount:", res.Data.FileCount, ) fmt.Println("*************************************") for _, info := range res.Data.Infos { fmt.Println("Name:", info.Name, "\nBizAttr:", info.BizAttr, "\nFileSize:", info.FileSize, "\nFileLen:", info.FileLen, "\nSha:", info.Sha, "\nCtime:", info.Ctime, "\nMtime:", info.Mtime, "\nAccess URL:", info.AccessUrl, ) fmt.Println("*************************************") }
func (*Client) PrefixSearchWithCallback ¶
func (c *Client) PrefixSearchWithCallback(bucket, path, prefix, context string, pattern ListPattern, num int, order ListOrder, callback func(*ListFolderResponse, error))
基于回调函数的搜索目录和文件接口, 调用该函数可立即返回, 搜索完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径 prefix: 搜索前缀 context: Context 用于翻页, 需要往前/往后翻页需透传回来 pattern: 目录列举模式, 可选值为 Both(列举目录和文件), DirectoryOnly(仅列举目录), FileOnly(仅列举文件) num: 本次拉取的目录和文件总数 order: 目录列举排序规则, 可选值为 Asc(正序), Desc(反序)
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.PrefixSearchWithCallback("cosdemo", "/hello", "", cos.Both, 100, cos.Asc, func(res *cos.ListFolderResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nContext:", res.Data.Context, "\nHasMore:", res.Data.HasMore, "\nDirCount:", res.Data.DirCount, "\nFileCount:", res.Data.FileCount, ) fmt.Println("*************************************") for _, info := range res.Data.Infos { fmt.Println("Name:", info.Name, "\nBizAttr:", info.BizAttr, "\nFileSize:", info.FileSize, "\nFileLen:", info.FileLen, "\nSha:", info.Sha, "\nCtime:", info.Ctime, "\nMtime:", info.Mtime, "\nAccess URL:", info.AccessUrl, ) fmt.Println("*************************************") } }) wg.Wait()
func (*Client) PrepareToUploadSlice ¶
func (c *Client) PrepareToUploadSlice(bucket, dstPath, srcPath, bizAttr, session string, sliceSize int64) (*UploadSliceResponse, error)
大文件分片上传(首次上传)
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 srcPath: 本地文件路径 bizAttr: 文件属性, 由业务端维护 session: 唯一标识此文件传输过程的id, 由后台下发, 调用方透传 sliceSize: 分片大小, 用户可以根据网络状况自行设置
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.PrepareToUploadSlice("cosdemo", "/hello/hello.bin", "/Users/bigfile.bin", "file attr", "", 512 * 1024) if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nSession:", res.Session, "\nOffset:", res.Offset, "\nSliceSize:", res.SliceSize, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) StatFile ¶
func (c *Client) StatFile(bucket, path string) (*StatFileResponse, error)
查询文件属性
bucket: Bucket 名称 path: 文件路径
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.StatFile("cosdemo", "/hello/new.txt") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nName:", res.Data.Name, "\nBizAttr:", res.Data.BizAttr, "\nFileSize:", res.Data.FileSize, "\nFileLen:", res.Data.FileLen, "\nSha:", res.Data.Sha, "\nCtime:", res.Data.Ctime, "\nMtime:", res.Data.Mtime, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) StatFileAsync ¶
func (c *Client) StatFileAsync(bucket, path string) <-chan *StatFileAsyncResponse
查询文件属性异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 文件路径
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.StatFileAsync("cosdemo", "/hello/new.txt") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nName:", res.Data.Name, "\nBizAttr:", res.Data.BizAttr, "\nFileSize:", res.Data.FileSize, "\nFileLen:", res.Data.FileLen, "\nSha:", res.Data.Sha, "\nCtime:", res.Data.Ctime, "\nMtime:", res.Data.Mtime, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) StatFileWithCallback ¶
func (c *Client) StatFileWithCallback(bucket, path string, callback func(*StatFileResponse, error))
基于回调函数的文件属性查询接口, 调用该函数可立即返回, 文件属性查询完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.StatFileWithCallback("cosdemo", "/hello/new.txt", func(res *cos.StatFileResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nName:", res.Data.Name, "\nBizAttr:", res.Data.BizAttr, "\nFileSize:", res.Data.FileSize, "\nFileLen:", res.Data.FileLen, "\nCtime:", res.Data.Ctime, "\nMtime:", res.Data.Mtime, "\nAccess Url:", res.Data.AccessUrl) }) wg.Wait()
func (*Client) StatFolder ¶
func (c *Client) StatFolder(bucket, path string) (*StatFolderResponse, error)
查询目录属性
bucket: Bucket 名称 path: 目录路径
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.StatFolder("cosdemo", "/hello") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nName:", res.Data.Name, "\nBizAttr:", res.Data.BizAttr, "\nCtime:", res.Data.Ctime, "\nMtime:", res.Data.Mtime)
func (*Client) StatFolderAsync ¶
func (c *Client) StatFolderAsync(bucket, path string) <-chan *StatFolderAsyncResponse
查询目录属性异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 目录路径
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.StatFolderAsync("cosdemo", "/hello") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nName:", res.Data.Name, "\nBizAttr:", res.Data.BizAttr, "\nCtime:", res.Data.Ctime, "\nMtime:", res.Data.Mtime, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) StatFolderWithCallback ¶
func (c *Client) StatFolderWithCallback(bucket, path string, callback func(*StatFolderResponse, error))
基于回调函数的目录属性查询接口, 调用该函数可立即返回, 目录属性查询完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.StatFolderWithCallback("cosdemo", "/hello", func(res *cos.StatFolderResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nName:", res.Data.Name, "\nBizAttr:", res.Data.BizAttr, "\nCtime:", res.Data.Ctime, "\nMtime:", res.Data.Mtime, "\nAccess Url:", res.Data.AccessUrl) }) wg.Wait()
func (*Client) UpdateFile ¶
func (c *Client) UpdateFile(bucket, path, bizAttr string) (*UpdateFileResponse, error)
更新文件属性
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.UpdateFile("cosdemo", "/hello", "hello-new-attr") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message)
func (*Client) UpdateFileAsync ¶
func (c *Client) UpdateFileAsync(bucket, path, bizAttr string) <-chan *UpdateFileAsyncResponse
更新文件属性异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.UpdateFileAsync("cosdemo", "/hello", "hello-new-attr") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message)
func (*Client) UpdateFileWithCallback ¶
func (c *Client) UpdateFileWithCallback(bucket, path, bizAttr string, callback func(*UpdateFileResponse, error))
基于回调函数的文件属性更新接口, 调用该函数可立即返回, 文件属性更新完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.UpdateFileWithCallback("cosdemo", "/hello123/new.txt", "hello-new-attr", func(res *cos.UpdateFileResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message) }) wg.Wait()
func (*Client) UpdateFolder ¶
func (c *Client) UpdateFolder(bucket, path, bizAttr string) (*UpdateFolderResponse, error)
更新目录属性
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.UpdateFolder("cosdemo", "/hello", "hello-new-attr") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message)
func (*Client) UpdateFolderAsync ¶
func (c *Client) UpdateFolderAsync(bucket, path, bizAttr string) <-chan *UpdateFolderAsyncResponse
更新目录属性异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.UpdateFolderAsync("cosdemo", "/hello", "hello-new-attr") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message)
func (*Client) UpdateFolderWithCallback ¶
func (c *Client) UpdateFolderWithCallback(bucket, path, bizAttr string, callback func(*UpdateFolderResponse, error))
基于回调函数的目录属性更新接口, 调用该函数可立即返回, 目录属性更新完成后调用回调函数.
bucket: Bucket 名称 path: 目录路径 bizAttr: 目录属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) client.UpdateFolderWithCallback("cosdemo", "/hello123", "hello-new-attr", func(res *cos.UpdateFolderResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message) }) wg.Wait()
func (*Client) UploadChunk ¶
func (c *Client) UploadChunk(bucket, dstPath string, chunk []byte, bizAttr string) (*UploadFileResponse, error)
上传内存块至云端
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 chunk: 本地内存块 bizAttr: 文件属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.UploadChunk("cosdemo", "/hello/hello.txt", []bytes("Hello"), "test hello") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) UploadChunkAsync ¶
func (c *Client) UploadChunkAsync(bucket, dstPath string, chunk []byte, bizAttr string) <-chan *UploadFileAsyncResponse
上传内存块至云端异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 chunk: 本地内存块 bizAttr: 文件属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.UploadChunkAsync("cosdemo", "/hello/hello.txt", []bytes("Hello"), "test hello") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) UploadChunkWithCallback ¶
func (c *Client) UploadChunkWithCallback(bucket, dstPath string, chunk []byte, bizAttr string, callback func(*UploadFileResponse, error))
基于回调函数的内存块上传接口, 调用该函数可立即返回, 文件上传完成后调用回调函数.
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 chunk: 本地内存块 bizAttr: 文件属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) fmt.Println("Uploading...") client.UploadChunkWithCallback("cosdemo", "/hello/goasguen-cernvm-2015.pptx", []byte("file...bin"), "goasguen-cernvm-2015.pptx", func(res *cos.UploadChunkResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl) }) wg.Wait() fmt.Println("Uploaded...")
func (*Client) UploadFile ¶
func (c *Client) UploadFile(bucket, dstPath, srcPath, bizAttr string) (*UploadFileResponse, error)
上传文件
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 srcPath: 本地文件路径 bizAttr: 文件属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.UploadFile("cosdemo", "/hello/hello.txt", "/users/new.txt", "file attr") if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) UploadFileAsync ¶
func (c *Client) UploadFileAsync(bucket, dstPath, srcPath, bizAttr string) <-chan *UploadFileAsyncResponse
上传文件异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 srcPath: 本地文件路径 bizAttr: 文件属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.UploadFileAsync("cosdemo", "/hello/hello.txt", "/users/new.txt", "file attr") // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) UploadFileWithCallback ¶
func (c *Client) UploadFileWithCallback(bucket, dstPath, srcPath, bizAttr string, callback func(*UploadFileResponse, error))
基于回调函数的文件上传接口, 调用该函数可立即返回, 文件上传完成后调用回调函数.
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 srcPath: 本地文件路径 bizAttr: 文件属性, 由业务端维护
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) fmt.Println("Uploading...") client.UploadFileWithCallback("cosdemo", "/hello/goasguen-cernvm-2015.pptx", "/Users/goasguen-cernvm-2015.pptx", "goasguen-cernvm-2015.pptx", func(res *cos.UploadFileResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl) }) wg.Wait() fmt.Println("Uploaded...")
func (*Client) UploadSlice ¶
func (c *Client) UploadSlice(bucket, dstPath, srcPath, bizAttr, session string, sliceSize int64) (*UploadSliceResponse, error)
大文件分片上传
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 srcPath: 本地文件路径 bizAttr: 文件属性, 由业务端维护 session: 唯一标识此文件传输过程的id, 由后台下发, 调用方透传 sliceSize: 分片大小, 用户可以根据网络状况自行设置
示例:
client := cos.NewClient(appId, secretId, secretKey) res, err := client.UploadSlice("cosdemo", "/hello/hello.bin", "/users/bigfile.bin", "file attr", "", 512 * 1024) if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) UploadSliceAsync ¶
func (c *Client) UploadSliceAsync(bucket, dstPath, srcPath, bizAttr, session string, sliceSize int64) <-chan *UploadSliceAsyncResponse
大文件分片上传异步接口, 调用该函数可立即返回一管道, 调用方可在后续代码逻辑中读取该管道.
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 srcPath: 本地文件路径 bizAttr: 文件属性, 由业务端维护 session: 唯一标识此文件传输过程的id, 由后台下发, 调用方透传 sliceSize: 分片大小, 用户可以根据网络状况自行设置
示例:
client := cos.NewClient(appId, secretId, secretKey) resChan := client.UploadSliceAsync("cosdemo", "/hello/hello.bin", "/users/bigfile.bin", "file attr", "", 512 * 1024) // Do your other work here resAsync := <- resChan if resAsync.Error != nil { fmt.Println(resAsync.Error) return } res := resAsync.Response fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl)
func (*Client) UploadSliceWithCallback ¶
func (c *Client) UploadSliceWithCallback(bucket, dstPath, srcPath, bizAttr, session string, sliceSize int64, callback func(*UploadSliceResponse, error))
基于回调函数的大文件分片上传接口, 调用该函数可立即返回, 文件分片上传完成后调用回调函数.
bucket: Bucket 名称 dstpath: 目的文件路径, 须设置为腾讯云端文件路径 srcPath: 本地文件路径 bizAttr: 文件属性, 由业务端维护 session: 唯一标识此文件传输过程的id, 由后台下发, 调用方透传 sliceSize: 分片大小, 用户可以根据网络状况自行设置
示例:
client := cos.NewClient(appId, secretId, secretKey) var wg = sync.WaitGroup{} wg.Add(1) fmt.Println("Uploading...") client.UploadSliceWithCallback("cosdemo", "/hello/goasguen-cernvm-2015.pptx", "/Users/goasguen-cernvm-2015.pptx", "goasguen-cernvm-2015.pptx", "", 1024*512, func(res *cos.UploadSliceResponse, err error) { defer wg.Done() if err != nil { fmt.Println(err) return } fmt.Println("Code:", res.Code, "\nMessage:", res.Message, "\nUrl:", res.Data.Url, "\nResourcePath:", res.Data.ResourcePath, "\nAccess Url:", res.Data.AccessUrl) }) wg.Wait() fmt.Println("Uploaded...")
type CreateFolderAsyncResponse ¶
type CreateFolderAsyncResponse struct { Response *CreateFolderResponse Error error }
目录创建操作异步接口的返回结果封装
type CreateFolderRequest ¶
目录创建操作的请求参数封装
type CreateFolderResponse ¶
type CreateFolderResponse struct { Response Data struct { Ctime string `json:"ctime"` ResourcePath string `json:"resource_path"` } `json:"data"` }
目录创建操作的返回结果封装
type DeleteFileAsyncResponse ¶
type DeleteFileAsyncResponse struct { Response *DeleteFileResponse Error error }
文件删除操作异步接口的返回结果封装
type DeleteFolderAsyncResponse ¶
type DeleteFolderAsyncResponse struct { Response *DeleteFolderResponse Error error }
目录删除操作异步接口的返回结果封装
type ListFolderAsyncResponse ¶
type ListFolderAsyncResponse struct { Response *ListFolderResponse Error error }
目录列举及搜索操作异步接口的返回结果封装
type ListFolderRequest ¶
type ListFolderRequest struct { Op string `json:"op" url:"op"` Pattern string `json:"pattern" url:"pattern"` Context string `json:"context" url:"context"` Num int `json:"num" url:"num"` Order int `json:"order" url:"order"` }
目录列举及搜索操作的请求参数封装
type ListFolderResponse ¶
type ListFolderResponse struct { Response Data struct { Context string `json:"context"` HasMore bool `json:"has_more"` DirCount int `json:"dircount"` FileCount int `json:"filecount"` Infos []struct { Name string `json:"name"` BizAttr string `json:"biz_attr"` FileSize int64 `json:"filesize"` FileLen int64 `json:"filelen"` Sha string `json:"sha"` Ctime string `json:"ctime"` Mtime string `json:"mtime"` AccessUrl string `json:"access_url"` } `json:"infos"` } `json:"data"` }
目录列举及搜索操作的返回结果封装
type ListPattern ¶
type ListPattern int
目录搜索模式, 细分为:
Both : 列举目录和文件 DirectoryOnly: 仅列举目录 FileOnly : 仅列举文件
const ( Both ListPattern = iota // 列举目录和文件 DirectoryOnly // 仅列举目录 FileOnly // 仅列举文件 )
func (ListPattern) String ¶
func (p ListPattern) String() string
字符串化目录搜索模式, 可能的返回值为: eListBoth, eListDirOnly, eListFileOnly
type PrepareToUploadSliceRequest ¶
type PrepareToUploadSliceRequest struct { Op string `json:"op"` FileSize int64 `json:"filesize"` Sha string `json:"sha"` BizAttr string `json:"biz_attr"` Session string `json:"session"` SliceSize int64 `json:"slice_size"` }
初次文件分片上传操作的请求参数封装
type StatFileAsyncResponse ¶
type StatFileAsyncResponse struct { Response *StatFileResponse Error error }
文件查询操作异步接口的返回结果封装
type StatFileResponse ¶
type StatFileResponse struct { Response Data struct { Name string `json:"name"` BizAttr string `json:"biz_attr"` FileSize string `json:"filesize"` FileLen string `json:"filelen"` Sha string `json:"sha"` Ctime string `json:"ctime"` Mtime string `json:"mtime"` AccessUrl string `json:"access_url"` } `json:"data"` }
文件查询操作的返回结果封装
type StatFolderAsyncResponse ¶
type StatFolderAsyncResponse struct { Response *StatFolderResponse Error error }
目录查询操作异步接口的返回结果封装
type StatFolderResponse ¶
type StatFolderResponse struct { Response Data struct { Name string `json:"name"` BizAttr string `json:"biz_attr"` Ctime string `json:"ctime"` Mtime string `json:"mtime"` } `json:"data"` }
目录查询操作的返回结果封装
type UpdateFileAsyncResponse ¶
type UpdateFileAsyncResponse struct { Response *UpdateFileResponse Error error }
文件属性更新操作异步接口的返回结果封装
type UpdateFileRequest ¶
文件属性更新操作的请求参数封装
type UpdateFolderAsyncResponse ¶
type UpdateFolderAsyncResponse struct { Response *UpdateFolderResponse Error error }
目录更新操作异步接口的返回结果封装
type UpdateFolderRequest ¶
目录更新操作的请求参数封装
type UploadFileAsyncResponse ¶
type UploadFileAsyncResponse struct { Response *UploadFileResponse Error error }
文件上传操作异步接口的返回结果封装
type UploadFileRequest ¶
type UploadFileRequest struct { Op string `json:"op"` FileContent string `json:"filecontent"` Sha string `json:"sha"` BizAttr string `json:"biz_attr"` }
文件上传操作的请求参数封装
type UploadFileResponse ¶
type UploadFileResponse struct { Response Data struct { AccessUrl string `json:"access_url"` Url string `json:"url"` ResourcePath string `json:"resource_path"` } `json:"data"` }
文件上传操作的返回结果封装
type UploadSliceAsyncResponse ¶
type UploadSliceAsyncResponse struct { Response *UploadSliceResponse Error error }
文件分片上传操作异步接口的返回结果封装
type UploadSliceRequest ¶
type UploadSliceRequest struct { Op string `json:"op"` FileContent string `json:"filecontent"` Sha string `json:"sha"` Session string `json:"session"` SliceSize int64 `json:"slice_size"` Offset int64 `json:"offset"` }
后续文件分片上传操作的请求参数封装
type UploadSliceResponse ¶
type UploadSliceResponse struct { Response Data struct { Session string `json:"session"` Offset int64 `json:"offset"` SliceSize int64 `json:"slice_size"` AccessUrl string `json:"access_url"` Url string `json:"url"` ResourcePath string `json:"resource_path"` } `json:"data"` }
文件分片上传操作的返回结果封装