delete doc

doc/上传文件.md

@@ -1,393 +0,0 @@
-# 上传文件
-OSS Go SDK提供了丰富的文件上传接口，用户可以通过以下方式向OSS中上传文件：
-
-- 简单上传PutObject，适合小文件
-- 分片上传UploadFile，适合大文件
-- 追加上传AppendObject
-
-## 简单上传
-
-### 从数据流(io.Reader)中读取数据上传
-
-通过Bucket.PutObject完成简单上传。
-
-> 提示：
-> 
-> - 简单上传的示例代码在`sample/put_object.go`。
-
-#### 字符串上传
-```go
-    import "strings"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-  
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.PutObject("my-object", strings.NewReader("MyObjectValue"))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-#### byte数组上传
-```go
-    import "bytes"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-   
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.PutObject("my-object", bytes.NewReader([]byte("MyObjectValue")))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-#### 文件流上传
-```go
-    import "os"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-   
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    fd, err := os.Open("LocalFile")
-    if err != nil {
-        // HandleError(err)
-    }
-    defer fd.Close()
-    
-    err = bucket.PutObject("my-object", fd)
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-### 根据本地文件名上传
-
-通过Bucket.PutObjectFromFile可以上传指定的本地文件，把本地文件内容作为Object的值。
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.PutObjectFromFile("my-object", "LocalFile")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 注意：
-> 
-> - 使用上述方法上传最大文件不能超过5G。如果超过请使用分片上传。
-
-
-### 上传时指定元信息
-
-使用数据流上传文件时，用户可以指定一个或多个文件的元信息。元数据的名称大小写不敏感，比如用户上传文件时，定义名字为“name”的meta，使用Bucket.GetObjectDetailedMeta读取结果是：“X-Oss-Meta-Name”，比较/读取时请忽略大小写。
-
-可以指定的元信息如下：
-
-| 参数 | 说明 |
-| :--- | :--- |
-| CacheControl | 指定该Object被下载时的网页的缓存行为。|
-| ContentDisposition | 指定该Object被下载时的名称。|
-| ContentEncoding | 指定该Object被下载时的内容编码格式。|
-| Expires | 指定过期时间。用户自定义格式，建议使用http.TimeFormat格式。|
-| ServerSideEncryption | 指定oss创建object时的服务器端加密编码算法。合法值：AES256。|
-| ObjectACL | 指定oss创建object时的访问权限。|
-| Meta | 自定义参数，以"X-Oss-Meta-"为前缀的参数。|
-
-```go
-    import (
-        "strings"
-        "time"
-        "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    )
-    
-	client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-	if err != nil {
-		// HandleError(err)
-	}
-
-	bucket, err := client.Bucket("my-bucket")
-	if err != nil {
-		// HandleError(err)
-	}
-
-	expires := time.Date(2049, time.January, 10, 23, 0, 0, 0, time.UTC)
-	options := []oss.Option{
-		oss.Expires(expires),
-		oss.ObjectACL(oss.ACLPublicRead),
-		oss.Meta("MyProp", "MyPropVal"),
-	}
-	err = bucket.PutObject("my-object", strings.NewReader("MyObjectValue"), options...)
-	if err != nil {
-		// HandleError(err)
-	}
-```
-
-> 提示：
-> - Bucket.PutObject、Bucket.PutObjectFromFile、Bucket.UploadFile、Bucket.UploadFile都支持上传时指定元数据。
-
-
-### 创建模拟文件夹
-
-OSS服务是没有文件夹这个概念的，所有元素都是以文件来存储。但给用户提供了创建模拟文件夹的方式，如下代码：
-```go
-    import "strings"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-   
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.PutObject("my-dir/", strings.NewReader(""))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 提示：
-> 
-> - 创建模拟文件夹本质上来说是创建了一个空文件。
-> - 对于这个文件照样可以上传下载,只是控制台会对以"/"结尾的文件以文件夹的方式展示。
-> - 所以用户可以使用上述方式来实现创建模拟文件夹。
-> - 而对文件夹的访问可以参看[文件夹功能模拟]({{doc/[5]SDK/Go-SDK/管理文件.md}})
->
-
-## 追加上传
-OSS支持可追加的文件类型，通过`Bucket.AppendObject`来上传可追加的文件，
-调用时需要指定文件追加的位置，对于新创建文件，这个位置是0；对于已经存
-在的文件，这个位置必须是追加前文件的长度。
-
-- 文件不存在时，调用`AppendObject`会创建一个可追加的文件；
-- 文件存在时，调用`AppendObject`会向文件末尾追加内容。
-
-> 提示：
-> - 追加上传的示例代码在`sample/append_object.go`。
-
-```go
-    import "strings"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    var nextPos int64 = 0
-    // 第一次追加的位置是0，返回值为下一次追加的位置
-    nextPos, err = bucket.AppendObject("my-object", strings.NewReader("YourObjectValue"), nextPos)
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 第二次追加
-    nextPos, err = bucket.AppendObject("my-object", strings.NewReader("YourObjectValue"), nextPos)
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 您还可以进行多次Append
-```
-
-> 注意：
-> 
-> - 只能向可追加的文件（即通过`AppendObject`创建的文件）追加内容
-> - 可追加的文件不能被拷贝
-> 
-
-第一次追加时，即位置开始位置是0的追加，您可以指定文件(Object)的元信息；除了第一次追加，其它追加不能指定元信息。
-```go
-    // 第一次追加指定元信息
-    nextPos, err = bucket.AppendObject("my-object", strings.NewReader("YourObjectValue"), 0, oss.Meta("MyProp", "MyPropVal"))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## 分片上传
-当上传大文件时，如果网络不稳定或者程序崩溃了，则整个上传就失败了。用户
-不得不重头再来，这样做不仅浪费资源，在网络不稳定的情况下，往往重试多次
-还是无法完成上传。
-通过`Bucket.UploadFile`接口来实现断点续传上传。它有以下参数：
-
-- objectKey 上传到OSS的Object名字
-- filePath 待上传的本地文件路径
-- partSize 分片上传大小，从100KB到5GB，单位是Byte
-- options 可选项，主要包括：
-  * Routines 指定分片上传的并发数，默认是1，及不使用并发上传
-  * Checkpoint 指定上传是否开启断点续传，及checkpoint文件的路径。默认断点续传功能关闭，checkpoint文件的路径可以指定为空，为与本地文件同
-    目录下的`file.cp`，其中`file`是本地文件的名字
-  * 其它元信息，请参看`上传时指定元信息`
-
-其实现的原理是将要上传的文件分成若干个分片分别上传，最后所有分片都上传
-成功后，完成整个文件的上传。在上传的过程中会记录当前上传的进度信息（记
-录在checkpoint文件中），如果上传过程中某一分片上传失败，再次上传时会从
-checkpoint文件中记录的点继续上传。这要求再次调用时要指定与上次相同的
-checkpoint文件。上传完成后，checkpoint文件会被删除。
-
-> 提示：
-> - 分片上传的示例代码在`sample/put_object.go`。
->
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 分片大小100K，3个协程并发上传分片，使用断点续传
-	err = bucket.UploadFile("my-object", "LocalFile", 100*1024, oss.Routines(3), oss.Checkpoint(true, ""))
-	if err != nil {
-		// HandleError(err)
-	}
-```
-
-> 注意：
-> - SDK会将上传的中间状态信息记录在cp文件中，所以要确保用户对cp文件有写权限
-> - cpt文件记录了上传的中间状态信息并自带了校验，用户不能去编辑它，如
->   果cpt文件损坏则重新上传所有分片。整个上传完成后cpt文件会被删除。
-> - 如果上传过程中本地文件发生了改变，则重新上传所有分片
-
-> 提示：
-> - 指定断点续传checkpoint文件路径使用`oss.Checkpoint(true, "your-cp-file.cp")`
-> - 使用`bucket.UploadFile(objectKey, localFile, 100*1024)`，默认不使用分片并发上传、不启动断点续传
-
-
-### 获取所有已上传的分片信息
-您可以用Bucket.ListUploadedParts获取某个分片上传已上传的分片。
-```go 
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    imur, err := bucket.InitiateMultipartUpload("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    lsRes, err := bucket.ListUploadedParts(imur)
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Parts:", lsRes.UploadedParts)
-```
-
-
-### 获取所有分片上传的任务
-通过`Bucket.ListMultipartUploads`来列出当前分片上传任务。主要的参数如下：
-
-| 参数 | 说明 |
-| :--- | :--- |
-| Delimiter | 用于对Object名字进行分组的字符。所有名字包含指定的前缀且第一次出现delimiter字符之间的object作为一组元素。 
-| MaxUploads | 限定此次返回Multipart Uploads事件的最大数目，默认为1000，max-uploads取值不能大于1000。
-| KeyMarker | 所有Object名字的字典序大于KeyMarker参数值的Multipart事件。 
-| Prefix  | 限定返回的文件名(object)必须以Prefix作为前缀。注意使用Prefix查询时，返回的文件名(Object)中仍会包含Prefix。   
-
-#### 使用默认参数
-```go 
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    lsRes, err := bucket.ListMultipartUploads()
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Uploads:", lsRes.Uploads)
-```
-
-#### 指定前缀
-```go     
-    lsRes, err := bucket.ListMultipartUploads(oss.Prefix("my-object-"))
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Uploads:", lsRes.Uploads)
-```
-
-#### 指定最多返回100条结果数据
-```go     
-    lsRes, err := bucket.ListMultipartUploads(oss.MaxUploads(100))
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Uploads:", lsRes.Uploads)
-```
-
-#### 同时指定前缀和最大返回条数
-```go     
-    lsRes, err := bucket.ListMultipartUploads(oss.Prefix("my-object-"), oss.MaxUploads(100))
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Uploads:", lsRes.Uploads)
-```

doc/下载文件.md

@@ -1,255 +0,0 @@
-# 下载文件(Object)
-
-OSS Go SDK提供了丰富的文件下载接口，用户可以通过以下方式从OSS中下载文件：
-
-- 下载到流io.ReadCloser
-- 下载到本地文件
-- 分片下载
-
-## 下载到流io.ReadCloser
-
-> 提示：
-> 
-> - 下载的示例代码在`sample/get_object.go`。
-> 
-
-### 下载文件到流
-```go
-    import (
-        "fmt"
-        "io/ioutil"
-        "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    )
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-	body, err := bucket.GetObject("my-object")
-	if err != nil {
-		// HandleError(err)
-	}
-	data, err := ioutil.ReadAll(body)
-	if err != nil {
-		// HandleError(err)
-	}
-	body.Close()
-	fmt.Println("data:", string(data))
-```
-
-> 注意：
-> 
-> - io.ReadCloser数据读取完毕后，需要调用Close关闭。
-> 
-
-### 下载文件到缓存
-```go
-    import (
-        "bytes"
-        "io"
-        "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    )
-    
-	client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    body, err := bucket.GetObject("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-	buf := new(bytes.Buffer)
-	io.Copy(buf, body)
-	body.Close()
-```
-
-### 下载文件到本地文件流
-```go
-    import (
-            "io"
-            "os"
-            "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    )
-
-	client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    body, err := bucket.GetObject("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-    defer body.Close()
-	
-	fd, err := os.OpenFile("LocalFile", os.O_WRONLY|os.O_CREATE, 0660)
-    if err != nil {
-        // HandleError(err)  
-    }
-    defer fd.Close()
-	
-	io.Copy(fd, body)
-```
-
-## 下载到本地文件
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.GetObjectToFile("my-object", "LocalFile")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-
-## 分片下载
-
-当下载大文件时，如果网络不稳定或者程序崩溃了，则整个下载就失败了。用户
-不得不重头再来，这样做不仅浪费资源，在网络不稳定的情况下，往往重试多次
-还是无法完成下载。
-通过`Bucket.DownloadFile`接口来实现断点续传下载。它有以下参数：
-
-- objectKey 要下载的Object名字
-- filePath 下载到本地文件的路径
-- partSize 下载分片大小，从1B到5GB，单位是Byte
-- options 可选项，主要包括：
-  * Routines 指定分片下载的并发数，默认是1，及不使用并发下载
-  * Checkpoint 指定下载是否开启断点续传，及checkpoint文件的路径。默认断点续传功能关闭，checkpoint文件的路径可以指定为空，如果不指定则默认为与本地文件同
-    目录下的`file.cpt`，其中`file`是本地文件的名字
-  * 下载时限定条件，请参看`指定限定条件下载`
-
-其实现的原理是将要下载的Object分成若干个分片分别下载，最后所有分片都下
-载成功后，完成整个文件的下载。在下载的过程中会记录当前下载的进度信息
-（记录在checkpoint文件中）和已下载的分片，如果下载过程中某一分片下载失败，再次下
-载时会从checkpoint文件中记录的点继续下载。这要求再次调用时要指定与上次
-相同的checkpoint文件。下载完成后，checkpoint文件会被删除。
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.DownloadFile("my-object", "LocalFile", 100*1024, oss.Routines(3), oss.Checkpoint(true, ""))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 注意：
-> - SDK会将下载的中间状态信息记录在cp文件中，所以要确保用户对cpt文
->   件有写权限
-> - cpt文件记录了下载的中间状态信息并自带了校验，用户不能去编辑它，如
->   果cpt文件损坏则重新下载文件
-> - 如果下载过程中待下载的Object发生了改变（ETag改变），或者part文件丢
->   失或被修改，则重新下载文件
->
-
->
-> 提示：
-> - 指定断点续传checkpoint文件路径使用`oss.Checkpoint(true, "your-cp-file.cp")`
-> - 使用`bucket.DownloadFile(objectKey, localFile, 100*1024)`，默认不使用分片并发下载、不启动断点续传
->
-
-
-## 指定限定条件下载
-
-下载文件时，用户可以指定一个或多个限定条件，所有的限定条件都满足时下载，不满足时报错不下载文件。
-可以使用的限定条件如下：
-
-|参数|说明|
-|:---|:---|
-|IfModifiedSince|如果指定的时间早于实际修改时间，则正常传送。否则返回错误。|
-|IfUnmodifiedSince|如果传入参数中的时间等于或者晚于文件实际修改时间，则正常传输文件；否则返回错误。|
-|IfMatch|如果传入期望的ETag和object的 ETag匹配，则正常传输；否则返回错误。|
-|IfNoneMatch|如果传入的ETag值和Object的ETag不匹配，则正常传输；否则返回错误。|
-
-```go
-    import "time"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    date := time.Date(2015, time.November, 10, 23, 0, 0, 0, time.UTC)
-    
-    // 限定条件不满足，不下载文件
-    err = bucket.GetObjectToFile("my-object", "LocalFile", oss.IfModifiedSince(date))
-    if err == nil {
-        // HandleError(err)
-    }
-    
-    // 满足限定条件，下载文件
-    err = bucket.GetObjectToFile("my-object", "LocalFile", oss.IfUnmodifiedSince(date))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 提示：
-> 
-> - ETag的值可以通过Bucket.GetObjectDetailedMeta获取。
-> - Bucket.GetObject，Bucket.GetObjectToFile，Bucket.DownloadFile都支持限定条件。
->
-
-## 文件压缩下载
-文件可以压缩下载，目前支持GZIP压缩。Bucket.GetObject、Bucket.GetObjectToFile支持压缩功能。
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.GetObjectToFile("my-object.txt", "LocalFile.gzip", oss.AcceptEncoding("gzip"))
-    if err != nil {
-        // HandleError(err)
-    }
-```

doc/安装.md

@@ -1,40 +0,0 @@
-# SDK安装
-
-- github地址：https://github.com/aliyun/aliyun-oss-go-sdk
-- API文档地址：https://godoc.org/github.com/aliyun/aliyun-oss-go-sdk/oss
-
-### 要求
-
-- 开通阿里云OSS服务，并创建了AccessKeyId 和AccessKeySecret。
-- 如果您还没有开通或者还不了解阿里云OSS服务，请登录
-  [OSS产品主页](http://www.aliyun.com/product/oss)了解。
-- 如果还没有创建AccessKeyId和AccessKeySecret，请到
-  [阿里云Access Key管理](https://ak-console.aliyun.com/#/accesskey)创
-  建Access Key。
-- 您已经安装了Go编译运行环境。如果您未安装，请参考[Go安装](https://golang.org/doc/install/source)下载安装编译运行环境。
-  下载安装Go编译运行环境。Go安装完毕后请正确设置GOPATH变量，如果您需要了解更多GOPATH，请执行命令`go help gopath`。
-  
-### 安装
-
-#### GitHub安装
-
->
-> - 执行命令`go get github.com/aliyun/aliyun-oss-go-sdk/oss`获取远程代码包。
-> - 在您的代码中使用`import "github.com/aliyun/aliyun-oss-go-sdk/oss"`引入OSS Go SDK的包。
-> - 如果您需要查看示例程序，请到`https://github.com/aliyun/aliyun-oss-go-sdk/`下的sample目录。
->
-
-> 提示：
-> 
-> - 使用`go get`命令安装过程中，界面不会打印提示，如果网络较差，需要一段时间，请耐心等待。如果安装过程中发生超时，请再次执行`go get`安装。 
-> - 安装成功后，在您的安装路径下（即GOPATH变量中的第一个路径）,会有Go Sdk的库`pkg/linux_amd64/github.com/aliyun/aliyun-oss-go-sdk/oss.a`(win在`pkg\windows_amd64\github.com\aliyun\aliyun-oss-go-sdk\oss.a`)，
-源文件在`src/github.com/aliyun/aliyun-oss-go-sdk`，如果没有请重新安装。
->
-
-### 运行sample
-
-#### GitHub安装运行sample
-> - 拷贝示例文件。到OSS Go SDK的安装路径（即GOPATH变量中的第一个路径），进入OSS Go SDK的代码目录`src\github.com\aliyun\aliyun-oss-go-sdk`，
-把其下的sample目录和sample.go复制到您的测试工程src目录下。
-> - 修改sample/config.go里的endpoint、AccessKeyId、AccessKeySecret、BucketName等配置。
-> - 请在您的工程目录下执行`go run src/sample.go`。

doc/快速开始.md

@@ -1,185 +0,0 @@
-# 快速开始
-
-下面介绍如何使用OSS Go SDK来访问OSS服务，包括查看Bucket列表，查看文
-件列表，上传/下载文件和删除文件。使用OSS Go SDK，需要引入oss包`import github.com/aliyun/aliyun-oss-go-sdk/oss`。
-
-## 初始化Client
-
-初始化Client，即创建Client：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 提示：
-> 
-> - Endpoint的是OSS的访问域名，如杭州数据中的访问域名是`http://oss-cn-hangzhou.aliyuncs.com`，更
-> 详细的说明请参考[OSS访问域名](https://help.aliyun.com/document_detail/oss/user_guide/oss_concept/endpoint.html)。
-> - AccessKeyId和AccessKeySecret是OSS的访问密钥。更详细的说明请参考[OSS访问控制](https://help.aliyun.com/document_detail/oss/user_guide/security_management/access_control.html)。
-> - 您运行示例程序时，请将Endpoint，AccessKeyId和AccessKeySecret替换成您的实际配置。
->
-
-## 查看Bucket列表
-
-通过Client.ListBuckets查看Bucket列表：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    lsRes, err := client.ListBuckets()
-    if err != nil {
-        // HandleError(err)
-    } 
-
-    for _, bucket := range lsRes.Buckets {
-        fmt.Println("bucket:", bucket.Name)
-    }
-```
-
-> **注：**
-> 
-> 1. Bucket的命名规范请查看[创建Bucket]({{doc/[2]Get-Started/快速开始.md}})
-> 2. Bucket名字不能与OSS服务中其他用户已有的Bucket重复，所以你需要选择一个独
->    特的Bucket名字以避免创建失败
-
-## 获取Bucket
-Bucket的操作有Client的方法完成，如创建/删除Bucket、设置/清除Bucket的权限/生命周期/防盗链等，Object的操作有Bucket的方法完成，如上传/下载/删除文件、设置Object的访问权限等。用户可以通过Client.Bucket获取指定Bucket的操作句柄。
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## 查看文件列表
-
-通过Bucket.ListObjects查看Bucket中的文件列表：
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    lsRes, err := bucket.ListObjects()
-    if err != nil {
-        // HandleError(err)
-    }
-
-    for _, object := range lsRes.Objects {
-        fmt.Println("Object:", object.Key)
-    }
-```
-
-## 上传文件
-
-通过Bucket.PutObjectFromFile上传文件：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.PutObjectFromFile("my-object", "LocalFile")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-其中`LocalFile`是需要上传的本地文件的路径。上传成功后，可以通过
-`Bucket.ListObjects`来查看。
-
-## 下载文件
-
-通过Bucket.GetObject下载文件：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.GetObjectToFile("my-object", "LocalFile")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-其中`LocalFile`是文件保存的路径。下载成功后，可以打开文件查看其内容。
-
-## 删除文件
-
-通过Bucket.DeleteObject从Bucket中删除文件：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    err = bucket.DeleteObject("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-删除文件后可以通过`Bucket.ListObjects`来查看文件确实已经被删除。
-
-
-## 了解更多
-
-- [管理Bucket]({{doc/[5]SDK/Go-SDK/管理Bucket.md}})
-- [上传文件]({{doc/[5]SDK/Go-SDK/上传文件.md}})
-- [下载文件]({{doc/[5]SDK/Go-SDK/下载文件.md}})
-- [管理文件]({{doc/[5]SDK/Go-SDK/管理文件.md}})
-- [自定义域名绑定]({{doc/[5]SDK/Go-SDK/自定义域名绑定.md}})
-- [设置访问权限]({{doc/[5]SDK/Go-SDK/设置访问权限.md}})
-- [管理生命周期]({{doc/[5]SDK/Go-SDK/管理生命周期.md}})
-- [设置访问日志]({{doc/[5]SDK/Go-SDK/设置访问日志.md}})
-- [静态网站托管]({{doc/[5]SDK/Go-SDK/静态网站托管.md}})
-- [设置防盗链]({{doc/[5]SDK/Go-SDK/设置防盗链.md}})
-- [设置跨域资源共享]({{doc/[5]SDK/Go-SDK/设置跨域资源共享.md}})
-- [错误]({{doc/[5]SDK/Go-SDK/错误.md}})
-

doc/管理Bucket.md

@@ -1,169 +0,0 @@
-# 管理存储空间（Bucket）
-
-存储空间（Bucket）是OSS上的命名空间，也是计费、权限控制、日志记录等高级功能的管理实体。
-
-## 查看所有Bucket
-
-使用`Client.ListBuckets`接口列出当前用户下的所有Bucket，用户还可以指
-定`Prefix`等参数，列出Bucket名字为特定前缀的所有Bucket：
-
-> 提示：
-> 
-> - ListBuckets的示例代码在`sample/list_buckets.go`。
->
-
-```go
-    import (
-        "fmt"
-        "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    )
-  
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 列出Bucket，默认100条。
-    lsRes, err := client.ListBuckets()
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("buckets:", lsRes.Buckets)
-    
-    // 指定前缀筛选
-    lsRes, err = client.ListBuckets(oss.Prefix("my-bucket"))
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("buckets:", lsRes.Buckets)
-```
-
-## 创建Bucket
-
-> 提示：
-> 
-> - CreateBucket的示例代码在`sample/create_bucket.go`。
->
-
-使用`Client.CreateBucket`接口创建一个Bucket，用户需要指定Bucket的名字：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = client.CreateBucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-创建Bucket时不指定权限，使用默认权限oss.ACLPrivate。创建时用户可以指定Bucket的权限：
-```go
-    err = client.CreateBucket("my-bucket", oss.ACL(oss.ACLPublicRead))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 注意：
-> 
-> - Bucket的命名规范请查看[创建Bucket]({{doc/[2]Get-Started/快速开始.md}})
-> - 由于存储空间的名字是全局唯一的，所以必须保证您的Bucket名字不与别人的重复
-
-## 删除Bucket
-
-使用`Client.DeleteBucket`接口删除一个Bucket，用户需要指定Bucket的名字：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = client.DeleteBucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 注意：
-> 
-> - 如果该Bucket下还有文件存在，则需要先删除所有文件才能删除Bucket
-> - 如果该Bucket下还有未完成的上传请求，则需要通过`Bucket.ListMultipartUploads`和
->   `Bucket.AbortMultipartUpload`先取消那些请求才能删除Bucket。用法请参考
->   [API文档][sdk-api]
-
-## 查看Bucket是否存在
-
-用户可以通过`Client.IsBucketExist`接口查看当前用户的某个Bucket是否存在：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    isExist, err := client.IsBucketExist("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## Bucket访问权限
-
-用户可以设置Bucket的访问权限，允许或者禁止匿名用户对其内容进行读写。更
-多关于访问权限的内容请参考[访问权限][bucket-acl]
-
-> 提示：
-> 
-> - Bucket访问权限的示例代码`sample/bucket_acl.go`。
->
-
-### 查看Bucket的访问权限
-
-通过`Client.GetBucketACL`查看Bucket的ACL：
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    aclRes, err := client.GetBucketACL("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Bucket ACL:", aclRes.ACL)
-```
-
-### 设置Bucket的访问权限（ACL）
-
-通过`Client.SetBucketACL`设置Bucket的ACL：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = client.SetBucketACL("my-bucket", oss.ACLPublicRead)
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 提示：
-> 
-> - Bucket有三种权限私有读写、公共读私有写、公共读写，分布对应Go sdk的常量ACLPrivate、ACLPublicRead、ACLPublicReadWrite。
->
-
-[sdk-api]: http://www.rubydoc.info/gems/aliyun-sdk/0.1.6
-[oss-regions]: http://help.aliyun.com/document_detail/oss/user_guide/oss_concept/endpoint.html
-[bucket-acl]: http://help.aliyun.com/document_detail/oss/user_guide/security_management/access_control.html

doc/管理文件.md

@@ -1,474 +0,0 @@
-# 管理文件
-
-一个Bucket下可能有非常多的文件，SDK提供一系列的接口方便用户管理文件。
-
-## 列出存储空间中的文件
-通过`Bucket.ListObjects`来列出当前Bucket下的文件。主要的参数如下：
-
-| 参数 | 说明 |
-| :--- | :--- |
-| Delimiter | 用于对Object名字进行分组的字符。所有名字包含指定的前缀且第一次出现delimiter字符之间的object作为一组元素CommonPrefixes |
-| Prefix | 限定返回的object key必须以prefix作为前缀。注意使用prefix查询时，返回的key中仍会包含prefix |
-| MaxKeys | 限定此次返回object的最大数，如果不设定，默认为100，max-keys取值不能大于1000 |
-| Marker | 设定结果从marker之后按字母排序的第一个开始返回 | 
-
-> 提示：
-> 
-> - ListObjects的示例代码在`sample/list_objects.go`
->
-
-### 使用默认参数获取存储空间的文件列表，默认返回100条Object
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    lsRes, err := bucket.ListObjects()
-    if err != nil {
-        // HandleError(err)
-    }
-
-    fmt.Println("Objects:", lsRes.Objects)
-```
-
-### 指定最大返回数量，最多不能超过1000条
-```go
-    lsRes, err := bucket.ListObjects(oss.MaxKeys(200))
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Objects:", lsRes.Objects)
-```
-
-### 返回指定前缀的Object，默认最多返回100条
-```go
-    lsRes, err := bucket.ListObjects(oss.Prefix("my-object-"))
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Objects:", lsRes.Objects)
-```
-
-### 指定从某个Object(my-object-xx)后返回，默认最多100条
-```go
-    lsRes, err := bucket.ListObjects(oss.Marker("my-object-xx"))
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Objects:", lsRes.Objects)
-```
-
-### 分页获取所有Object，每次返回200条
-```go
-    marker := oss.Marker("")
-    for {
-        lsRes, err := bucket.ListObjects(oss.MaxKeys(200), marker)
-        if err != nil {
-            HandleError(err)
-        }
-        marker = oss.Marker(lsRes.NextMarker)
-        
-        fmt.Println("Objects:", lsRes.Objects)
-        
-        if !lsRes.IsTruncated {
-            break
-        }
-    }
-```
-
-### 分页所有获取从特定Object后的所有的Object，每次返回50条
-```go
-    marker = oss.Marker("my-object-xx")
-    for {
-        lsRes, err := bucket.ListObjects(oss.MaxKeys(50), marker)
-        if err != nil {
-            // HandleError(err)
-        }
-        
-        marker = oss.Marker(lsRes.NextMarker)
-        
-        fmt.Println("Objects:", lsRes.Objects)
-        
-        if !lsRes.IsTruncated {
-            break
-        }
-    }
-```
- 
-### 分页所有获取指定前缀为的Object，每次返回80个。
-```go
-    prefix := oss.Prefix("my-object-")
-    marker := oss.Marker("")
-    for {
-        lsRes, err := bucket.ListObjects(oss.MaxKeys(80), marker, prefix)
-        if err != nil {
-            // HandleError(err)
-        }
-        
-        prefix = oss.Prefix(lsRes.Prefix)
-        marker = oss.Marker(lsRes.NextMarker)
-        
-        fmt.Println("Objects:", lsRes.Objects)
-        
-        if !lsRes.IsTruncated {
-            break
-        }
-    }
-```
-
-### 模拟目录结构
-
-OSS是基于对象的存储服务，没有目录的概念。存储在一个Bucket中所有文件都
-是通过文件的key唯一标识，并没有层级的结构。这种结构可以让OSS的存储非常
-高效，但是用户管理文件时希望能够像传统的文件系统一样把文件分门别类放到
-不同的“目录”下面。通过OSS提供的“公共前缀”的功能，也可以很方便地模拟目录
-结构。公共前缀的概念请参考 [列出Object]({{doc/[8]用户手册/管理文件/列出Object.md}}) 。
-
-假设Bucket中已有如下文件：
-
-    foo/x
-    foo/y
-    foo/bar/a
-    foo/bar/b
-    foo/hello/C/1
-    foo/hello/C/2
-
-通过ListObjects，列出指定目录下的文件和子目录：
-
-```go
-    lsRes, err := bucket.ListObjects(oss.Prefix("foo/"), oss.Delimiter("/"))
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Objects:", lsRes.Objects,"SubDir:", lsRes.CommonPrefixes)
-```
-
-结果中lsRes.Objects为文件，包括foo/x、foo/y；lsRes.CommonPrefixes即子目录，包括foo/bar/、foo/hello/。
-
-
-## 判断文件是否存在
-
-通过Bucket.IsObjectExist来判断文件是否存在。
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    isExist, err := bucket.IsObjectExist("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-``` 
-
-
-## 删除单个文件
-
-通过`Bucket.DeleteObject`来删除某个文件：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.DeleteObject("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## 删除多个文件
-
-通过`Bucket.DeleteObjects`来删除多个文件，用户可以通过`DeleteObjectsQuiet`参
-数来指定是否返回删除的结果。默认返回删除结果。
-
-> 提示：
-> - 删除文件的示例代码在`sample/delete_object.go`
-
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 默认返回删除成功的文件
-    delRes, err := bucket.DeleteObjects([]string{"my-object-1", "my-object-2"})
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Deleted Objects:", delRes.DeletedObjects)
-    
-    // 不返回删除的结果
-    _, err = bucket.DeleteObjects([]string{"my-object-3", "my-object-4"}, 
-        oss.DeleteObjectsQuiet(true))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 注意：
-> 
-> - Bucket.DeleteObjects至少有一个ObjectKey，不能为空。
-> - Bucket.DeleteObjects使用的Go的xml包，该包实现了XML1.0标准，XML1.0不支持的特性请不要使用。
->
-
-## 获取文件的元信息(Object Meta)
-
-OSS上传/拷贝文件时，除了文件内容，还可以指定文件的一些属性信息，称为“元信息”。这些信息在上传时与文件一起存储，在下载时与文件一起返回。
-
-在SDK中文件元信息用一个`Map`表示，其他key和value都是`string`类型，并
-且都**只能是简单的ASCII可见字符，不能包含换行。** 所有元信息的总大小不
-能超过8KB。
-
-> 注意：
-> 
-> - 因为文件元信息在上传/下载时是附在HTTP Headers中， HTTP协议规定不能
->   包含复杂字符。
-> - 元数据的名称大小写不敏感，比较/读取时请忽略大小写。
-
-使用Bucket.GetObjectDetailedMeta来获取Object的元信息。
-
-> 提示：
-> - 元信息的示例代码在`sample/object_meta.go`
-
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    props, err := bucket.GetObjectDetailedMeta("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Object Meta:", props)
-``` 
-
-> 提示：
-> 
-> - Bucket.GetObjectMeta的结果中不包括Object的权限，获取Object权限通过Bucket.GetObjectACL。
-> 
-
-## 修改文件元信息(Object Meta)
-
-用户一次修改一条或多条元信息，可用元信息如下：
-
-|元信息|说明|
-|:---|:---|
-|CacheControl|指定新Object被下载时的网页的缓存行为。|
-|ContentDisposition|指定新Object被下载时的名称。|
-|ContentEncoding|指定新Object被下载时的内容编码格式。|
-|Expires|指定新Object过期时间，建议使用GMT格式。|
-|Meta|自定义参数，以"X-Oss-Meta-"为前缀的参数。|
-
-使用Bucket.SetObjectMeta来设置Object的元信息。
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 一次修改一条Meta
-    err = bucket.SetObjectMeta("my-object", oss.Meta("MyMeta", "MyMetaValue"))
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 修改多条Meta
-    options := []oss.Option{
-        oss.Meta("MyMeta", "MyMetaValue"),
-        oss.Meta("MyObjectLocation", "HangZhou"),
-    }
-    err = bucket.SetObjectMeta("my-object", options...)
-    if err != nil {
-        // HandleError(err)
-    }
-```  
-
-## 拷贝文件
-
-使用`Bucket.CopyObject`或`Bucket.CopyObjectToBucket`拷贝文件，前者是同一个Bucket内的文件拷贝，后者是Bucket之间的文件拷贝。
-
-> 提示：
-> - 拷贝文件的示例代码在`sample/copy_objects.go`
-
-### 同一个Bucket内的文件拷贝
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    _, err = bucket.CopyObject("my-object", "descObjectKey")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-### 不同Bucket之间的文件拷贝
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    _, err = bucket.CopyObjectToBucket("my-object", "my-bucket-desc", "descObjectKey")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-### 拷贝时处理文件元信息
-
-文件拷贝(CopyObject/CopyObjectToBucket)时对文件元信息的处理有两种选择，通过`MetadataDirective`参数指定：
-
-- oss.MetaCopy 与源文件相同，即拷贝源文件的元信息
-- oss.MetaReplace 使用新的元信息覆盖源文件的信息
-
-默认值是oss.MetaCopy。
-
-COPY时，MetadataDirective为MetaReplace时，用户可以指定新对象的如下的元信息：
-
-|元信息|说明|
-|:---|:---|
-|CacheControl|指定新Object被下载时的网页的缓存行为。|
-|ContentDisposition|指定新Object被下载时的名称。|
-|ContentEncoding|指定新Object被下载时的内容编码格式。|
-|Expires|指定新Object过期时间（seconds）更详细描述请参照RFC2616。|
-|ServerSideEncryption|指定OSS创建新Object时的服务器端加密编码算法。|
-|ObjectACL|指定OSS创建新Object时的访问权限。 |
-|Meta|自定义参数，以"X-Oss-Meta-"为前缀的参数。|
-
-```go
-    import (
-        "time"
-        "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    )
-        
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    expires := time.Date(2049, time.January, 10, 23, 0, 0, 0, time.UTC)
-    options := []oss.Option{
-        oss.MetadataDirective(oss.MetaReplace),
-        oss.Expires(expires),
-        oss.ObjectACL(oss.ACLPublicRead),
-        oss.Meta("MyMeta", "MyMetaValue")}
-    
-    _, err = bucket.CopyObject("my-object", "descObjectKey", options...)
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-### 限定拷贝条件
-文件拷贝时可以设置限定条件，条件满足时拷贝，不满足时报错不拷贝。可以使用的限定条件如下：
-
-|参数|说明|
-|:---|:---|
-|CopySourceIfMatch|如果源Object的ETAG值和用户提供的ETAG相等，则执行拷贝操作；否则返回错误。|
-|CopySourceIfNoneMatch|如果源Object的ETAG值和用户提供的ETAG不相等，则执行拷贝操作；否则返回错误。|
-|CopySourceIfModifiedSince|如果传入参数中的时间等于或者晚于源文件实际修改时间，则正常拷贝；否则返回错误。|
-|CopySourceIfUnmodifiedSince|如果源Object自从用户指定的时间以后被修改过，则执行拷贝操作；否则返回错误。|
-
-```go
-    import (
-        "fmt"
-        "time"
-        "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    )
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    date := time.Date(2015, time.November, 10, 23, 0, 0, 0, time.UTC)
-    // 约束条件不满足，拷贝没有执行
-    _, err = bucket.CopyObject("my-object", "descObjectKey", oss.CopySourceIfModifiedSince(date))
-    fmt.Println("CopyObjectError:", err)
-    
-    // 约束条件满足，拷贝执行
-    _, err = bucket.CopyObject("my-object", "descObjectKey", oss.CopySourceIfUnmodifiedSince(date))
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 提示：
-> 
-> - Bucket.CopyObject、Bucket.CopyObjectToBucket都支持拷贝时处理文件元信息、限定拷贝条件。
-> 

doc/管理生命周期.md

@@ -1,78 +0,0 @@
-# 管理生命周期（Lifecycle）
-
-OSS允许用户对Bucket设置生命周期规则，以自动淘汰过期掉的文件，节省存储
-空间。用户可以同时设置多条规则，一条规则包含：
-
-- 规则ID，用于标识一条规则，不能重复
-- 受影响的文件前缀，此规则只作用于符合前缀的文件
-- 过期时间，有两种指定方式：
-  1. 指定距文件最后修改时间N天过期
-  2. 指定在具体的某一天过期，即在那天之后符合前缀的文件将会过期，**而
-     不论文件的最后修改时间**。不推荐使用。
-- 是否生效
-
-更多关于生命周期的内容请参考 [文件生命周期]({{doc/[8]用户手册/管理文件/Object生命周期管理.md}})
-
-> 提示：
-> 
-> - 管理生命周期的示例代码在`sample/bucket_lifecycle.go`。
-
-## 设置生命周期规则
-
-通过`Client.SetBucketLifecycle`来设置生命周期规则：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // id:"rule1", enable:true, prefix:"foo/", expiry:Days 3
-    rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)
-    // id:"rule2", enable:false, prefix:"bar/", expiry:Date 2016/1/1
-    rule2 := oss.BuildLifecycleRuleByDate("rule2", "bar/", true, 2016, 1, 1)
-    rules := []oss.LifecycleRule{rule1, rule2}
-    
-    err = client.SetBucketLifecycle("my-bucket", rules)
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## 查看生命周期规则
-
-通过`Client.GetBucketLifecycle`来查看生命周期规则：
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    lcRes, err := client.GetBucketLifecycle("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Lifecycle Rules:", lcRes.Rules)
-```
-
-## 清空生命周期规则
-
-通过`Client.DeleteBucketLifecycle`设置一个空的Rule数组来清空生命周期规则：
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = client.DeleteBucketLifecycle("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-```   

doc/自定义域名绑定.md

@@ -1,74 +0,0 @@
-# 自定义域名绑定
-
-OSS支持用户将自定义的域名绑定到OSS服务上，这样能够支持用户无缝地将存储
-迁移到OSS上。例如用户的域名是my-domain.com，之前用户的所有图片资源都是
-形如`http://img.my-domain.com/xx.jpg`的格式，用户将图片存储迁移到OSS之
-后，通过绑定自定义域名，仍可以使用原来的地址访问到图片：
-
-- 开通OSS服务并创建Bucket
-- 将img.my-domain.com与创建的Bucket绑定
-- 将图片上传到OSS的这个Bucket中
-- 修改域名的DNS配置，增加一个CNAME记录，将img.my-domain.com指向OSS服务
-  的endpoint（如my-bucket.oss-cn-hangzhou.aliyuncs.com）
-
-这样就可以通过原地址`http://img.my-domain.com/x.jpg`访问到存储在OSS上
-的图片。
-绑定自定义域名请参考[自定义域名绑定]({{doc/[8]用户手册/基本概念/自定义域名访问OSS.md}})
-
-在使用SDK时，可以使用自定义域名作为endpoint，这时需要将`UseCname`参数
-设置为true，如下面的例子：
-
-> 提示：
-> 
-> - 跨域资源共享的示例代码在`sample/cname_sample.go`。
-
-```go
-    import ( 
-    	"fmt"
-        "io/ioutil"
-        "strings"
-        "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    )
-        
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret", oss.UseCname(true))
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = bucket.PutObject("my-object", strings.NewReader("MyObjectValue"))
-    if err != nil {
-        // HandleError(err)
-    }
-    
-	body, err := bucket.GetObject("my-object")
-	if err != nil {
-		// HandleError(err)
-	}
-	data, err := ioutil.ReadAll(body)
-	if err != nil {
-		// HandleError(err)
-	}
-	body.Close()
-	data = data  // 处理数据
-    
-    lsRes, err := bucket.ListObjects()
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Objects:", lsRes.Objects)
-    
-    err = bucket.DeleteObject("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-> 注意：
-> 
-> - 使用Cname时，无法使用list_buckets接口。（因为自定义域名已经绑定到
->   某个特定的Bucket）

doc/设置访问日志.md

@@ -1,76 +0,0 @@
-# 设置访问日志（Logging）
-
-OSS允许用户对Bucket设置访问日志记录，设置之后对于Bucket的访问会被记录
-成日志，日志存储在OSS上由用户指定的Bucket中，文件的格式为：
-
-    <TargetPrefix><SourceBucket>-YYYY-mm-DD-HH-MM-SS-UniqueString
-
-其中`TargetPrefix`由用户指定。日志规则由以下3项组成：
-
-- enable，是否开启
-- target_bucket，存放日志文件的Bucket
-- target_prefix，指定最终被保存的访问日志文件前缀
-
-更多关于访问日志的内容请参考 [Bucket访问日志]({{doc/[8]用户手册/安全管理/设置访问日志记录.md}})
-
-> 提示：
-> 
-> - Bucket访问权限设置的示例代码在`sample/bucket_logging.go`。
-
-## 开启Bucket日志
-
-通过`Client.SetBucketLogging`来开启日志功能：
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // target_bucket:"my-target-bucket", target_prefix:"my-object-", enable: true
-    err = client.SetBucketLogging("my-bucket", "my-target-bucket", "my-object-", true)
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## 查看Bucket日志设置
-
-通过`Client.GetBucketLogging`来查看日志设置：
-
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    logRes, err := client.GetBucketLogging("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Target Bucket:", logRes.LoggingEnabled.TargetBucket, 
-                "Target Prefix:", logRes.LoggingEnabled.TargetPrefix)
-```
-
-## 关闭Bucket日志
-
-通过`Bucket.DeleteBucketLogging`来关闭日志功能：
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = client.DeleteBucketLogging("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-```

doc/设置访问权限.md

@@ -1,96 +0,0 @@
-# 设置访问权限（ACL）
-
-OSS允许用户对Bucket和Object分别设置访问权限，方便用户控制自己的资源可
-以被如何访问。对于Bucket，有三种访问权限：
-
-- public-read-write 允许匿名用户向该Bucket中创建/获取/删除Object
-- public-read 允许匿名用户获取该Bucket中的Object
-- private 不允许匿名访问，所有的访问都要经过签名
-
-创建Bucket时，默认是private权限。之后用户可以通过`Client.SetBucketACL`来设置
-Bucket的权限。上面三种权限分布对应Go SDK中的常量ACLPublicReadWrite、ACLPublicRead、ACLPrivate。
-
-## Bucket访问权限
-
-> 提示：
-> 
-> - Bucket访问权限设置的示例代码在`sample/bucket_acl.go`。
-
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 设置Bucket ACL
-    err = client.SetBucketACL("my-bucket", oss.ACLPublicRead)
-    if err != nil {
-        // HandleError(err)
-    }
-
-    // 查看Bucket ACL
-    aclRes, err := client.GetBucketACL("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Bucket ACL:", aclRes.ACL)
-```
-
-## Object访问权限
-
-对于Object，有四种访问权限：
-
-- default 继承所属的Bucket的访问权限，即与所属Bucket的权限值一样
-- public-read-write 允许匿名用户读写该Object
-- public-read 允许匿名用户读该Object
-- private 不允许匿名访问，所有的访问都要经过签名
-
-创建Object时，默认为default权限。之后用户可以通过
-`Bucket.SetObjectACL`来设置Object的权限。上面四种权限分布对应
-Go SDK中的常量ACLDefault、ACLPublicReadWrite、ACLPublicRead、ACLPrivate。
-
-> 提示：
-> 
-> - Object访问权限设置的示例代码在`sample/object_acl.go`。
-
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    bucket, err := client.Bucket("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // 设置Object的访问权限
-    err = bucket.SetObjectACL("my-object", oss.ACLPrivate)
-    if err != nil {
-        // HandleError(err)
-    }
-
-    // 查看Object的访问权限
-    aclRes, err := bucket.GetObjectACL("my-object")
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Object ACL:", aclRes.ACL)
-    
-```
-
-
-> 注意：
->
-> - 如果设置了Object的权限（非default），则访问该Object时进行权限认证时
-   会优先判断Object的权限，而Bucket的权限设置会被忽略。
-> -  允许匿名访问时（设置了public-read或者public-read-write权限），用户
-   可以直接通过浏览器访问，例如 : `http://bucket-name.oss-cn-hangzhou.aliyuncs.com/object.jpg`
-
-更多关于访问权限控制的内容请参考 [访问控制]({{doc/[8]用户手册/安全管理/访问控制.md}})

doc/设置跨域资源共享.md

@@ -1,88 +0,0 @@
-# 设置跨域资源共享（CORS）
-
-跨域资源共享(CORS)允许web端的应用程序访问不属于本域的资源。OSS提供接口
-方便开发者控制跨域访问的权限。更多关于跨域资源共享的内容请参考
-[OSS跨域资源共享]({{doc/[8]用户手册/安全管理/设置跨域访问.md}})
-
-OSS的跨域共享设置由一条或多条CORS规则组成，每条CORS规则包含以下设置：
-
-- allowed_origins，允许的跨域请求的来源，如www.my-domain.com, *
-- allowed_methods，允许的跨域请求的HTTP方法(PUT/POST/GET/DELETE/HEAD)
-- allowed_headers，在OPTIONS预取指令中允许的header，如x-oss-test, *
-- expose_headers，允许用户从应用程序中访问的响应头
-- max_age_seconds, 浏览器对特定资源的预取（OPTIONS）请求返回结果的缓存时间
-
-> 提示：
-> 
-> - 跨域资源共享的示例代码在`sample/bucket_cors.go`。
-
-## 设置CORS规则
-
-通过`Client.SetBucketCORS`设置CORS规则：
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    rule1 := oss.CORSRule{
-        AllowedOrigin: []string{"*"},
-        AllowedMethod: []string{"PUT", "GET"},
-        AllowedHeader: []string{},
-        ExposeHeader:  []string{},
-        MaxAgeSeconds: 200,
-    }
-    
-    rule2 := oss.CORSRule{
-        AllowedOrigin: []string{"http://www.a.com", "http://www.b.com"},
-        AllowedMethod: []string{"POST"},
-        AllowedHeader: []string{"Authorization"},
-        ExposeHeader:  []string{"x-oss-test", "x-oss-test1"},
-        MaxAgeSeconds: 100,
-    }
-    
-    err = client.SetBucketCORS("my-bucket", []oss.CORSRule{rule1, rule2})
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## 查看CORS规则
-
-通过`Client.GetBucketCORS`查看CORS规则：
-
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    corsRes, err := client.GetBucketCORS("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Bucket CORS:", corsRes.CORSRules)
-```
-
-## 清空CORS规则
-
-通过`Client.DeleteBucketCORS`清空CORS规则
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = client.DeleteBucketCORS("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-```

doc/设置防盗链.md

@@ -1,73 +0,0 @@
-# 设置防盗链（Referer）
-
-OSS是按使用收费的服务，为了防止用户在OSS上的数据被其他人盗链，OSS支持
-基于HTTP header中表头字段referer的防盗链方法。更多OSS防盗链请参考：
-[OSS防盗链]({{doc/[8]用户手册/安全管理/设置防盗链.md}})
-
-> 提示：
-> 
-> - 设置防盗链的示例代码在`sample/bucket_referer.go`。
-
-## 设置Referer白名单
-
-通过`Bucket.SetBucketReferer`设置Referer白名单，该函数有三个参数：
-    
-- bucketName 存储空间名称。 
-- referers 访问白名单列表。一个bucket可以支持多个referer参数。eferer参数支持通配符"*"和"?"。
-- allowEmptyReferer 指定是否允许referer字段为空的请求访问。默认配置为true。
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    referers := []string{"http://www.aliyun.com",
-                         "http://www.???.aliyuncs.com",
-                         "http://www.*.com"}
-    err = client.SetBucketReferer("my-bucket", referers, false)
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## 查看Referer白名单
-
-通过`Bucket.GetBucketReferer`设置Referer白名单：
-
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    refRes, err := client.GetBucketReferer("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-    fmt.Println("Referers:", refRes.RefererList, 
-                "AllowEmptyReferer:", refRes.AllowEmptyReferer)
-```
-
-## 清空Referer白名单
-
-清空Referer白名单，即把白名单设置成空，allowEmptyReferer为true：
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = client.SetBucketReferer("my-bucket", []string{}, true)
-    if err != nil {
-        // HandleError(err)
-    }
-```

doc/错误.md

@@ -1,90 +0,0 @@
-# 错误(error)
-
-Go中调用出错，会统一返回接口error，该接口定义如下：
-```go
-    type error interface {
-        Error() string
-    }
-```
-其它的错误继承于该接口。比如HTTP错误请求返回的错误如下：
-```go
-    //net.Error 
-    type Error interface {
-        error
-        Timeout() bool   // Is the error a timeout
-        Temporary() bool // Is the error temporary
-    }
-```
-使用OSS Go SDK时如果请求出错，会有相应的error返回。HTTP请求、IO等错误会返回Go预定的错误。
-OSS Server处理请求出错，返回如下的错误，该错误实现了error接口。
-```go
-    type ServiceError struct {
-        Code       string    // OSS返回给用户的错误码
-        Message    string    // OSS给出的详细错误信息
-        RequestId  string    // 用于唯一标识该次请求的UUID
-        HostId     string    // 用于标识访问的OSS集群
-        StatusCode int       // HTTP状态码
-    }
-```
-如果OSS返回的HTTP状态码与预期不符返回如下错误，该错误也实现了error接口。
-```go
-    type UnexpectedStatusCodeError struct {
-        allowed []int    // 预期OSS返回HTTP状态码
-        got     int      // OSS实际返回HTTP状态码
-    }
-```
-
-## OSS的错误码
-OSS的错误码列表如下：
-
-| 错误码 | 描述 | HTTP状态码 |
-| :--- | :--- | :--- |
-|AccessDenied | 拒绝访问 | 403 |
-|BucketAlreadyExists | Bucket已经存在 | 409 |
-|BucketNotEmpty | Bucket不为空 | 409 |
-|EntityTooLarge | 实体过大 | 400 |
-|EntityTooSmall | 实体过小 | 400 |
-|FileGroupTooLarge | 文件组过大 | 400 |
-|InvalidLinkName | Object Link与指向的Object同名 | 400 |
-|LinkPartNotExist | Object Link中指向的Object不存在 | 400 |
-|ObjectLinkTooLarge | Object Link中Object个数过多 | 400 |
-|FieldItemTooLong | Post请求中表单域过大 | 400 |
-|FilePartInterity | 文件Part已改变 | 400 |
-|FilePartNotExist | 文件Part不存在 | 400 |
-|FilePartStale | 文件Part过时 | 400 |
-|IncorrectNumberOfFilesInPOSTRequest | Post请求中文件个数非法 | 400 |
-|InvalidArgument | 参数格式错误 | 400 |
-|InvalidAccessKeyId | AccessKeyId不存在 | 403 |
-|InvalidBucketName | 无效的Bucket名字 | 400 |
-|InvalidDigest | 无效的摘要 | 400 |
-|InvalidEncryptionAlgorithmError | 指定的熵编码加密算法错误 | 400 |
-|InvalidObjectName | 无效的Object名字 | 400 |
-|InvalidPart | 无效的Part | 400 |
-|InvalidPartOrder | 无效的part顺序 | 400 |
-|InvalidPolicyDocument | 无效的Policy文档 | 400 |
-|InvalidTargetBucketForLogging | Logging操作中有无效的目标bucket | 400 |
-|InternalError | OSS内部发生错误 | 500 |
-|MalformedXML | XML格式非法 | 400 |
-|MalformedPOSTRequest | Post请求的body格式非法 | 400 |
-|MaxPOSTPreDataLengthExceededError | Post请求上传文件内容之外的body过大 | 400 |
-|MethodNotAllowed | 不支持的方法 | 405 |
-|MissingArgument | 缺少参数 | 411 |
-|MissingContentLength | 缺少内容长度 | 411 |
-|NoSuchBucket | Bucket不存在 | 404 |
-|NoSuchKey | 文件不存在 | 404 |
-|NoSuchUpload | Multipart Upload ID不存在 | 404 |
-|NotImplemented | 无法处理的方法 | 501 |
-|PreconditionFailed | 预处理错误 | 412 |
-|RequestTimeTooSkewed | 发起请求的时间和服务器时间超出15分钟 | 403 |
-|RequestTimeout | 请求超时 | 400 |
-|RequestIsNotMultiPartContent | Post请求content-type非法 | 400 |
-|SignatureDoesNotMatch | 签名错误 | 403 |
-|TooManyBuckets | 用户的Bucket数目超过限制 | 400 |
-|InvalidEncryptionAlgorithmError | 指定的熵编码加密算法错误 | 400 |
-
-
-> 提示：
-> 
-> - 上表的错误码即OssServiceError.Code，HTTP状态码即OssServiceError.StatusCode。
-> - 如果试图以OSS不支持的操作来访问某个资源，返回405 Method Not Allowed错误。
-> 

doc/静态网站托管.md

@@ -1,67 +0,0 @@
-# 托管静态网站（Website）
-
-在[自定义域名绑定]({{doc/[5]SDK/Ruby-SDK/自定义域名绑定.md}})中提到，OSS
-允许用户将自己的域名指向OSS服务的地址。这样用户访问他的网站的时候，实
-际上是在访问OSS的Bucket。对于网站，需要指定首页(index)和出错页(error)
-分别对应的Bucket中的文件名。
-
-更多关于静态网站托管的内容请参考 [OSS静态网站托管]({{doc/[8]用户手册/静态网站托管.md}})
-
-## 设置托管页面
-
-通过`Client.SetBucketWebsite`来设置托管页面：
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    // bucketName:"my-bucket", indexWebsite:"index.html", errorWebsite:"error.html"
-    err = client.SetBucketWebsite("my-bucket", "index.html", "error.html")
-    if err != nil {
-        // HandleError(err)
-    }
-```
-
-## 查看托管页面
-
-通过`Client.GetBucketWebsite`来查看托管页面：
-
-```go
-    import "fmt"
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    wsRes, err := client.GetBucketWebsite("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-
-    fmt.Println("indexWebsite:", wsRes.IndexDocument.Suffix, 
-                "errorWebsite:", wsRes.ErrorDocument.Key)
-```
-
-## 清除托管页面
-
-通过`Client.DeleteBucketWebsite`来清除托管页面：
-
-```go
-    import "github.com/aliyun/aliyun-oss-go-sdk/oss"
-    
-    client, err := oss.New("Endpoint", "AccessKeyId", "AccessKeySecret")
-    if err != nil {
-        // HandleError(err)
-    }
-    
-    err = client.DeleteBucketWebsite("my-bucket")
-    if err != nil {
-        // HandleError(err)
-    }
-```