// Update the Object from in with modTime and size
func (o *Object) Update(in io.Reader, src fs.ObjectInfo) error {
modTime := src.ModTime()
uploader := s3manager.NewUploader(o.fs.ses, func(u *s3manager.Uploader) {
u.Concurrency = 2
u.LeavePartsOnError = false
u.S3 = o.fs.c
u.PartSize = s3manager.MinUploadPartSize
size := src.Size()
// Adjust PartSize until the number of parts is small enough.
if size/u.PartSize >= s3manager.MaxUploadParts {
// Calculate partition size rounded up to the nearest MB
u.PartSize = (((size / s3manager.MaxUploadParts) >> 20) + 1) << 20
}
})
// Set the mtime in the meta data
metadata := map[string]*string{
metaMtime: aws.String(swift.TimeToFloatString(modTime)),
}
// Guess the content type
mimeType := fs.MimeType(src)
key := o.fs.root + o.remote
req := s3manager.UploadInput{
Bucket: &o.fs.bucket,
ACL: &o.fs.acl,
Key: &key,
Body: in,
ContentType: &mimeType,
Metadata: metadata,
//ContentLength: &size,
}
if o.fs.sse != "" {
req.ServerSideEncryption = &o.fs.sse
}
if o.fs.storageClass != "" {
req.StorageClass = &o.fs.storageClass
}
_, err := uploader.Upload(&req)
if err != nil {
return err
}
// Read the metadata from the newly created object
o.meta = nil // wipe old metadata
err = o.readMetaData()
return err
}
func (client *s3client) UploadFile(bucketName string, remotePath string, localPath string, options UploadFileOptions) (string, error) {
uploader := s3manager.NewUploader(client.session)
stat, err := os.Stat(localPath)
if err != nil {
return "", err
}
localFile, err := os.Open(localPath)
if err != nil {
return "", err
}
defer localFile.Close()
progress := client.newProgressBar(stat.Size())
progress.Start()
defer progress.Finish()
uploadInput := s3manager.UploadInput{
Bucket: aws.String(bucketName),
Key: aws.String(remotePath),
Body: progressSeekReaderAt{localFile, progress},
ACL: aws.String(options.Acl),
}
if options.ServerSideEncryption != "" {
uploadInput.ServerSideEncryption = aws.String(options.ServerSideEncryption)
}
if options.KmsKeyId != "" {
uploadInput.SSEKMSKeyId = aws.String(options.KmsKeyId)
}
if options.ContentType != "" {
uploadInput.ContentType = aws.String(options.ContentType)
}
uploadOutput, err := uploader.Upload(&uploadInput)
if err != nil {
return "", err
}
if uploadOutput.VersionID != nil {
return *uploadOutput.VersionID, nil
}
return "", nil
}
func (self *S3Filesystem) Create(src File) error {
var fullpath string
if self.path == "" || strings.HasSuffix(self.path, "/") {
fullpath = filepath.Join(self.path, src.Relative())
} else {
fullpath = self.path
}
input := s3manager.UploadInput{
ACL: aws.String(acl),
Bucket: aws.String(self.bucket),
Key: aws.String(fullpath),
}
switch t := src.(type) {
case *S3File:
// special case for S3File to preserve header information
getObjectInput := s3.GetObjectInput{
Bucket: aws.String(t.bucket),
Key: t.object.Key,
}
output, err := self.conn.GetObject(&getObjectInput)
if err != nil {
return err
}
defer output.Body.Close()
input.Body = output.Body
// transfer existing headers across
input.ContentType = output.ContentType
// input.LastModified = output.LastModified
input.StorageClass = output.StorageClass
default:
reader, err := src.Reader()
if err != nil {
return err
}
input.Body = reader
defer reader.Close()
input.ContentType = aws.String(guessMimeType(src.Relative()))
}
u := s3manager.NewUploaderWithClient(self.conn)
_, err := u.Upload(&input)
return err
}