cos

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) IsTimeout ¶

func (c Client) IsTimeout(err error) bool

判断客户端是否超时

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) SetTimeout ¶

func (c *Client) SetTimeout(timeout time.Duration)

设置客户端 HTTP 请求超时时长

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...")

func (ListOrder) Int ¶

func (l ListOrder) Int() int

func (ListPattern) String ¶

func (p ListPattern) String() string

字符串化目录搜索模式, 可能的返回值为: eListBoth, eListDirOnly, eListFileOnly