Question

我正在尝试使用Mitchell Hashimoto的goamz fork提供的PutPart方法。可悲的是，每当我收回零件并检查尺寸时，它似乎认为它是整个文件的大小而不仅仅是一块。

例如

上传15米文件时，我希望看到

Uploading...
Processing 1 part of 3 and uploaded 5242880.0 bytes.
 Processing 2 part of 3 and uploaded 5242880.0 bytes.
 Processing 3 part of 3 and uploaded 5242880.0 bytes.

相反，我看到了：

Uploading...
Processing 1 part of 3 and uploaded 15728640 bytes.
 Processing 2 part of 3 and uploaded 15728640 bytes.
 Processing 3 part of 3 and uploaded 15728640 bytes.

这是由于file.Read（partBuffer）的问题吗？任何帮助将非常感激。

我在mac上使用了1.5.1。

package main

import (
    "bufio"
    "fmt"
    "math"
    "net/http"
    "os"

    "github.com/mitchellh/goamz/aws"
    "github.com/mitchellh/goamz/s3"
)

func check(err error) {
    if err != nil {
        panic(err)
    }
}

func main() {
    fmt.Println("Test")

    auth, err := aws.GetAuth("XXXXX", "XXXXXXXXXX")
    check(err)

    client := s3.New(auth, aws.USWest2)

    b := s3.Bucket{
        S3:   client,
        Name: "some-bucket",
    }

    fileToBeUploaded := "testfile"
    file, err := os.Open(fileToBeUploaded)
    check(err)
    defer file.Close()

    fileInfo, _ := file.Stat()
    fileSize := fileInfo.Size()
    bytes := make([]byte, fileSize)

    // read into buffer
    buffer := bufio.NewReader(file)
    _, err = buffer.Read(bytes)
    check(err)
    filetype := http.DetectContentType(bytes)

    // set up for multipart upload
    multi, err := b.InitMulti("/"+fileToBeUploaded, filetype, s3.ACL("bucket-owner-read"))
    check(err)

    const fileChunk = 5242880 // 5MB
    totalPartsNum := uint64(math.Ceil(float64(fileSize) / float64(fileChunk)))
    parts := []s3.Part{}

    fmt.Println("Uploading...")
    for i := uint64(1); i < totalPartsNum; i++ {

        partSize := int(math.Min(fileChunk, float64(fileSize-int64(i*fileChunk))))
        partBuffer := make([]byte, partSize)

        _, err := file.Read(partBuffer)
        check(err)

        part, err := multi.PutPart(int(i), file) // write to S3 bucket part by part
        check(err)

        fmt.Printf("Processing %d part of %d and uploaded %d bytes.\n ", int(i), int(totalPartsNum), int(part.Size))
        parts = append(parts, part)
    }

    err = multi.Complete(parts)
    check(err)

    fmt.Println("\n\nPutPart upload completed")

}

Answer 1

这里的问题可能是因为没有完全读取文件。 Read可能有点微妙：

读取读取最多len（p）个字节到p。它返回读取的字节数（0 <= n <= len（p））和遇到的任何错误。即使Read返回n＆lt; len（p），它可以在调用期间将所有p用作临时空间。如果某些数据可用但不是len（p）字节，则Read会按常规返回可用内容而不是等待更多内容。

所以你应该使用ioReadFull或（更好）io.CopyN。

那就是说我认为您应该尝试切换到AWS Go官方软件包。他们有一个方便的Uploader，它将为您处理所有这些：

package main

import (
    "log"
    "os"

    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3/s3manager"
)

func main() {
    bucketName := "test-bucket"
    keyName := "test-key"
    file, err := os.Open("example")
    if err != nil {
        log.Fatalln(err)
    }
    defer file.Close()

    sess := session.New()
    uploader := s3manager.NewUploader(sess)

    // Perform an upload.
    result, err := uploader.Upload(&s3manager.UploadInput{
        Bucket: &bucketName,
        Key:    &keyName,
        Body:   file,
    })
    if err != nil {
        log.Fatalln(err)
    }
    log.Println(result)
}

您可以在godoc.org找到更多文档。

Answer 2

您在partBuffer中读取的数据根本未被使用。您将file传递到multi.PutPart，并且会读取file的全部内容，并根据需要将其重新开始，并将您的所有工作都清除掉已经完成了。

对代码的最小更改是将bytes.NewReader(partBuffer)传递给PutPart，而不是file。 bytes.Reader实现了io.ReadSeeker所需的PutPart界面，并且还会将其大小报告为partBuffer。

另一种方法是使用io.SectionReader类型 - 而不是自己将数据读入缓冲区，只需根据SectionReader创建一系列file的大小和你想要的偏移量并将它们传递给PutPart，它们会将读取传递给底层文件阅读器。这应该也可以正常工作，并大大减少你必须编写（和错误检查）的代码。它还避免了不必要地缓冲RAM中的一大块数据。

Answer 3

当您将文件部分传递给 multi.PutPart 方法（n， strings.NewReader （“”））时，您的代码必须更改某些点这可以正常工作，下面的代码将起作用。

记住PutPart发送多部分上传的一部分，读取r中的所有内容，除最后一部分外，每个部分的大小必须至少为。它在goamz docs中有描述。

点我已改为正常工作：

这里我创建了包含文件所有字节的headerPart

HeaderPart：= strings.NewReader（string（bytes））

这里 io.ReadFull（HeaderPart，partBuffer）我正在读取 make（[] byte，partSize）命令的整个缓冲区部分，每次都是位于文件的某个部分。

当我们运行 multi.PutPart（int（i）+1，strings.NewReader（string（partBuffer）））时，我们必须+1，因为它不计算0部分而是为了传递目标文件，我们将使用 strings.NewReader 函数传递部分内容。

查看下面的代码，它现在可以正常使用。

package main

import(
"bufio"
"fmt"
"math"
"net/http"
"os"
"launchpad.net/goamz/aws"
"launchpad.net/goamz/s3"
)

func check(err error) {
    if err != nil {
     panic(err)
    } 
}

func main() {

fmt.Println("Test")

auth := aws.Auth{
    AccessKey: "xxxxxxxxxxx", // change this to yours
    SecretKey: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
}

client := s3.New(auth, aws.USWest2)

b := s3.Bucket{
    S3:   client,
    Name: "some-bucket",
}

fileToBeUploaded := "testfile"
file, err := os.Open(fileToBeUploaded)
check(err)
defer file.Close()

fileInfo, _ := file.Stat()
fileSize := fileInfo.Size()
bytes := make([]byte, fileSize)

// read into buffer
buffer := bufio.NewReader(file)
_, err = buffer.Read(bytes)
check(err)
filetype := http.DetectContentType(bytes)

// set up for multipart upload
multi, err := b.InitMulti("/"+fileToBeUploaded, filetype, s3.ACL("bucket-owner-read"))
check(err)

const fileChunk = 5242880 // 5MB
totalPartsNum := uint64(math.Ceil(float64(fileSize) / float64(fileChunk)))
parts := []s3.Part{}

fmt.Println("Uploading...")

HeaderPart := strings.NewReader(string(bytes))

for i := uint64(0); i < totalPartsNum; i++ {

    partSize := int(math.Min(fileChunk, float64(fileSize-int64(i*fileChunk))))

    partBuffer := make([]byte, partSize)

    n , errx := io.ReadFull(HeaderPart, partBuffer)

    check(errx)

    part, err := multi.PutPart(int(i)+1, strings.NewReader(string(partBuffer))) // write to S3 bucket part by part

    check(err)

    fmt.Printf("Processing %d part of %d and uploaded %d bytes.\n ", int(i), int(totalPartsNum), int(n))
    parts = append(parts, part)
}

err = multi.Complete(parts)
check(err)

fmt.Println("\n\nPutPart upload completed")
}

如何使用Go跟踪分段上传到s3的进度？

3 个答案: