func (this *StorageUtil) upload(fileName string, fileLocation string, fingerPrint string) (string, error) {
f, err := os.Open(fileLocation)
defer f.Close()
if err != nil {
return "", err
}
metadata := map[string]*string{}
metadata["fingerprint"] = &fingerPrint
uploader := s3manager.NewUploader(this.ssn)
result, err := uploader.Upload(&s3manager.UploadInput{
Bucket: &this.Bucket,
Key: &fileName,
Body: f,
Metadata: metadata,
})
if err != nil {
return "", err
} else {
return result.Location, nil
}
}
func main() {
flag.Parse()
if *filepath == "" || *bucket == "" {
fmt.Println("Please specify correct parameters!")
fmt.Println("You should specify:")
fmt.Println("-path with path to file you want to upload")
fmt.Println("-bucket name of bucket in S3 where you want to upload")
os.Exit(1)
}
file, err := os.Open(*filepath)
if err != nil {
fmt.Println("Failed to open a file.", err)
os.Exit(1)
}
session := session.New(createConfig())
service := s3manager.NewUploader(session)
resp, err := service.Upload(&s3manager.UploadInput{
Bucket: aws.String(*bucket),
Key: aws.String("/" + getFileName(*filepath)),
Body: file,
})
if err != nil {
fmt.Println("Failed to upload a file.", err)
os.Exit(1)
}
fmt.Println("---------------------")
fmt.Println("File was successfully uploaded!")
fmt.Println("Location:", resp.Location)
}
func main() {
flag.Parse()
if *filesPath == "" || *bucket == "" {
fmt.Println("Please specify correct parameters!")
fmt.Println("You should specify:")
fmt.Println("-path with path to file you want to upload")
fmt.Println("-bucket name of bucket in S3 where you want to upload")
os.Exit(1)
}
file, err := os.Open(*filesPath)
if err != nil {
log.Fatal("Failed to open a file with an error: ", err)
}
defer file.Close()
info, err := file.Stat()
if err != nil {
log.Fatal("Failed to get info about file with an error: ", err)
}
session := session.New(createConfig())
service := s3manager.NewUploader(session)
switch mode := info.Mode(); {
case mode.IsDir():
uploadDirectory(*service, *file)
case mode.IsRegular():
uploadFile(*service, *uploadPath+getFileName(*filesPath), file)
}
}
// Save will upload a file to S3
func (a *Amazon) Save(filepath, filename, mime string, expire bool) (err error) {
file, err := os.Open(filepath)
if err != nil {
return errors.New("problem opening file for s3")
}
defer file.Close()
uploader := s3manager.NewUploader(a.session)
// default cachecontrol header
var cache = "public, max-age=31536000"
// if we want the file to not be cached
if expire {
cache = "public, max-age=0"
}
params := &s3manager.UploadInput{
Bucket: aws.String(config.Settings.Amazon.Bucket),
Key: aws.String(filename),
Body: file,
ContentType: aws.String(mime),
CacheControl: aws.String(cache),
ServerSideEncryption: aws.String(s3.ServerSideEncryptionAes256),
}
_, err = uploader.Upload(params)
return
}
func (client *s3client) UploadFile(bucketName string, remotePath string, localPath string) (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()
uploadOutput, err := uploader.Upload(&s3manager.UploadInput{
Bucket: aws.String(bucketName),
Key: aws.String(remotePath),
Body: progress.NewProxyReader(localFile),
})
if err != nil {
return "", err
}
if uploadOutput.VersionID != nil {
return *uploadOutput.VersionID, nil
}
return "", nil
}
// Update the Object from in with modTime and size
func (o *Object) Update(in io.Reader, modTime time.Time, size int64) error {
uploader := s3manager.NewUploader(o.fs.ses, func(u *s3manager.Uploader) {
u.Concurrency = 2
u.LeavePartsOnError = false
u.S3 = o.fs.c
})
// Set the mtime in the meta data
metadata := map[string]*string{
metaMtime: aws.String(swift.TimeToFloatString(modTime)),
}
// Guess the content type
contentType := fs.MimeType(o)
key := o.fs.root + o.remote
req := s3manager.UploadInput{
Bucket: &o.fs.bucket,
ACL: &o.fs.perm,
Key: &key,
Body: in,
ContentType: &contentType,
Metadata: metadata,
//ContentLength: &size,
}
_, 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 uploadPackage(config *Config) error {
key := "package.zip"
uploadfile, err := os.Open(key)
if err != nil {
return err
}
//rlu := &rateLimitUploader{ fh: uploadfile }
fmt.Println("Uploading package.zip to", config.S3Bucket, "bucket...")
uploader := s3manager.NewUploader(session.New())
_, err = uploader.Upload(&s3manager.UploadInput{
Bucket: &config.S3Bucket,
Key: &key,
//Body: rlu,
Body: uploadfile,
})
if err != nil {
panic(err)
}
fmt.Println("Uploaded package.zip to", config.S3Bucket, "bucket.")
return nil
}
func (client *s3client) UploadFile(bucketName string, remotePath string, localPath string) (string, error) {
uploader := s3manager.NewUploader(&s3manager.UploadOptions{
S3: client.client,
})
localFile, err := os.Open(localPath)
if err != nil {
return "", err
}
defer localFile.Close()
// uploadOutput, err := uploader.Upload(&s3manager.UploadInput{
_, err = uploader.Upload(&s3manager.UploadInput{
Bucket: aws.String(bucketName),
Key: aws.String(remotePath),
Body: localFile,
})
if err != nil {
return "", err
}
// if uploadOutput.VersionID != nil {
// return *uploadOutput.VersionID, nil
// }
return "", nil
}
func TestUploadOrderMultiFailureLeaveParts(t *testing.T) {
s, ops, _ := loggingSvc(emptyList)
s.Handlers.Send.PushBack(func(r *service.Request) {
switch data := r.Data.(type) {
case *s3.UploadPartOutput:
if *data.ETag == "ETAG2" {
r.HTTPResponse.StatusCode = 400
}
}
})
mgr := s3manager.NewUploader(&s3manager.UploadOptions{
S3: s,
Concurrency: 1,
LeavePartsOnError: true,
})
_, err := mgr.Upload(&s3manager.UploadInput{
Bucket: aws.String("Bucket"),
Key: aws.String("Key"),
Body: bytes.NewReader(make([]byte, 1024*1024*12)),
})
assert.Error(t, err)
assert.Equal(t, []string{"CreateMultipartUpload", "UploadPart", "UploadPart"}, *ops)
}
// Write the local backup file to S3.
// There are no tests for this remote operation
func (b *Backup) writeBackupRemote() {
s3Conn := session.New(&aws.Config{Region: aws.String(string(b.Config.S3Region))})
t := time.Unix(b.StartTime, 0)
b.RemoteFilePath = fmt.Sprintf("%s/%v/%d/%v/%v", b.Config.ObjectPrefix, t.Year(), t.Month(), t.Day(), filepath.Base(b.FullFilename))
// re-read the compressed file. There is probably a better way to do this
localFileContents, err := ioutil.ReadFile(b.FullFilename)
if err != nil {
log.Fatalf("[ERR] Could not read compressed file!: %v", err)
}
// Create the params to pass into the actual uploader
params := &s3manager.UploadInput{
Bucket: &b.Config.S3Bucket,
Key: &b.RemoteFilePath,
Body: bytes.NewReader(localFileContents),
}
if b.Config.S3ServerSideEncryption != "" {
params.ServerSideEncryption = &b.Config.S3ServerSideEncryption
}
if b.Config.S3KmsKeyID != "" {
params.SSEKMSKeyId = &b.Config.S3KmsKeyID
}
log.Printf("[INFO] Uploading %v/%v to S3 in %v", string(b.Config.S3Bucket), b.RemoteFilePath, string(b.Config.S3Region))
uploader := s3manager.NewUploader(s3Conn)
_, err = uploader.Upload(params)
if err != nil {
log.Fatalf("[ERR] Could not upload to S3!: %v", err)
}
}
func fileToBucket(filename, bucket string) (size int64, err error) {
defer Track("fileToBucket", Now(), debugOut)
// Open the file
file, err := os.Open(filename)
if err != nil {
return
}
defer file.Close()
// Get the filesize
fi, ferr := file.Stat()
if ferr == nil {
size = fi.Size()
}
// Extract the basename
baseFilename := filepath.Base(filename)
// Setup the uploader, and git'r'done
svc := s3manager.NewUploader(AWSSession)
_, err = svc.Upload(&s3manager.UploadInput{
Bucket: aws.String(bucket),
Key: aws.String(baseFilename),
Body: file,
})
return
}
func TestUploadFailCleanup(t *testing.T) {
svc := s3.New(nil)
// Break checksum on 2nd part so it fails
part := 0
svc.Handlers.Build.PushBack(func(r *request.Request) {
if r.Operation.Name == "UploadPart" {
if part == 1 {
r.HTTPRequest.Header.Set("X-Amz-Content-Sha256", "000")
}
part++
}
})
key := "12mb-leave"
mgr := s3manager.NewUploader(&s3manager.UploadOptions{
S3: svc,
LeavePartsOnError: false,
})
_, err := mgr.Upload(&s3manager.UploadInput{
Bucket: bucketName,
Key: &key,
Body: bytes.NewReader(integBuf12MB),
})
assert.Error(t, err)
uploadID := ""
if merr, ok := err.(s3manager.MultiUploadFailure); ok {
uploadID = merr.UploadID()
}
assert.NotEmpty(t, uploadID)
_, err = svc.ListParts(&s3.ListPartsInput{
Bucket: bucketName, Key: &key, UploadId: &uploadID})
assert.Error(t, err)
}
func handleMultipartForm(req *http.Request, folderName string) (err error) {
// 10MB allocated for files
const _10mb = (1 << 22) * 24
if err = req.ParseMultipartForm(_10); err != nil {
return
}
uploader := s3manager.NewUploader(sess)
for _, fileHeaders := range req.MultipartForm.File {
for _, header := range fileHeaders {
var file multipart.File
if file, err = header.Open(); err != nil {
return
}
_, err = uploader.Upload(&s3manager.UploadInput{
Bucket: aws.String(conf.S3.BucketName),
Key: aws.String(fmt.Sprintf("%s/%s", folderName, header.Filename)),
Body: file,
})
if err != nil {
return
}
}
}
return
}
// Upload upload object
func (service Service) Upload(key string, filePath string) error {
if key == "" {
return fmt.Errorf("key must be a nonempty string")
}
if filePath == "" {
return fmt.Errorf("filePath must be a nonempty string")
}
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
uploader := s3manager.NewUploader(session.New())
_, err = uploader.Upload(&s3manager.UploadInput{
Bucket: aws.String(service.bucketSource),
Key: aws.String(key),
ACL: aws.String(s3.ObjectCannedACLPublicRead),
ContentType: aws.String(mime.TypeByExtension(path.Ext(key))),
Body: file,
})
return err
}
// WriteS3Object writes the data to the given key, optionally compressing it first
func WriteS3Object(data []string, config *aws.Config, bucket string, key string, lineSeparator string, compress bool) (string, error) {
var reader io.Reader
byteReader := strings.NewReader(strings.Join(data, lineSeparator))
if compress {
key = fmt.Sprintf("%v.gz", key)
pipeReader, pipeWriter := io.Pipe()
reader = pipeReader
go func() {
gw := gzip.NewWriter(pipeWriter)
io.Copy(gw, byteReader)
gw.Close()
pipeWriter.Close()
}()
} else {
reader = byteReader
}
uploader := s3manager.NewUploader(session.New(config))
result, err := uploader.Upload(&s3manager.UploadInput{
Body: reader,
Bucket: aws.String(bucket),
Key: aws.String(key),
})
return result.Location, err
}
func main() {
if len(os.Args) != 3 {
log.Fatal("wrong number of arguments")
}
src, _ := os.Args[1], os.Args[2]
creds := credentials.NewEnvCredentials()
if _, err := creds.Get(); err != nil {
log.Fatal(err)
}
svc := s3.New(&aws.Config{
Credentials: creds,
Region: "us-east-2",
Endpoint: "s3.amazonaws.com",
S3ForcePathStyle: true,
})
uploader := s3manager.NewUploader(&s3manager.UploadOptions{S3: svc})
watcher, err := fsnotify.NewWatcher()
if err != nil {
log.Fatal(err)
}
defer watcher.Close()
done := make(chan bool)
go func() {
for {
select {
case event := <-watcher.Events:
log.Println("event:", event)
switch event.Op {
case fsnotify.Create:
handleCreate(watcher, uploader, event.Name)
case fsnotify.Write:
log.Println("modified file:", event.Name)
}
case err := <-watcher.Errors:
log.Println("error:", err)
}
}
}()
err = filepath.Walk(src, func(path string, info os.FileInfo, err error) error {
if info.IsDir() {
log.Println(path)
return watcher.Add(path)
}
return nil
})
if err != nil {
log.Fatal(err)
}
<-done
}
func uploadSegmentsToS3(inputFolder string, s3id string, scanned func(string, bool), uploaded func(int, int)) error {
inputPath := scratchPath(inputFolder)
sess := session.New(&aws.Config{Region: aws.String("us-west-2")})
uploader := s3manager.NewUploader(sess, func(u *s3manager.Uploader) {
u.PartSize = 5 * 1024 * 1024
u.Concurrency = 5
})
files, err := ioutil.ReadDir(inputPath)
if err != nil {
return err
}
sort.Sort(ForPlayback(files))
totalFiles := len(files)
finishedFiles := make(chan string, len(files))
limiter := make(chan int, 10)
go func() {
for i := range files {
file := files[i]
log.Println("doing file", file.Name())
limiter <- 0
go func(fname string) {
fullpath := filepath.Join(inputPath, fname)
outpath := filepath.Join("media", s3id, fname)
file, err := os.Open(fullpath)
if err != nil {
scanned("Error opening file for upload", true)
log.Println("Error opening file for upload", err)
return
}
_, err = uploader.Upload(&s3manager.UploadInput{
Bucket: aws.String("smick-media-output"),
Key: aws.String(outpath),
Body: file,
})
file.Close()
os.Remove(fullpath)
finishedFiles <- fname
<-limiter
}(file.Name())
}
}()
for j := 1; j <= totalFiles; j++ {
fname := <-finishedFiles
logLine := fmt.Sprintf("Uploaded %s: %d of %d", fname, j, totalFiles)
scanned(logLine, false)
uploaded(j, totalFiles)
}
return nil
}
// newS3Client returns S3 service client
func newS3Client(cfg *aws.Config) *s3Client {
return &s3Client{
region: *cfg.Region,
client: s3.New(session.New(cfg)),
uploader: s3manager.NewUploader(session.New(cfg), func(u *s3manager.Uploader) {
u.PartSize = 64 * 1024 * 1024
}),
}
}
func NewUploader(c client.ConfigProvider, bucketName string) *S3Uploader {
m := s3manager.NewUploader(c)
u := S3Uploader{
uploader: m,
bucketName: bucketName,
}
return &u
}
func InitS3Uploader(config RepoConfig) *S3Uploader {
uploader := new(S3Uploader)
uploader.BucketName = aws.String(config.S3Bucket)
s3config := aws.Config{Region: aws.String(config.S3Region)}
s3uploader := s3manager.NewUploader(session.New(&s3config))
uploader.S3Uploader = s3uploader
return uploader
}
//Submits an audition in auditions/{auditionid}
func submitAuditionHandler(w http.ResponseWriter, r *http.Request) {
s := redis_session.Session(w, r)
fmt.Println(r.Form)
err := r.ParseMultipartForm(32 << 20)
if err != nil {
log.Printf("%s", err)
}
roleID := r.FormValue("id")
fmt.Println(r.Form)
file, handler, err := r.FormFile("auditionFile")
defer file.Close()
if err != nil {
fmt.Printf("err opening audition file: %s", err)
return
}
bytes, err := file.Seek(0, 2)
if err != nil {
panic(err)
}
var kilobytes int64
kilobytes = (bytes / 1024)
var megabytes float64
megabytes = (float64)(kilobytes / 1024)
if megabytes < 6 {
attachmentURL := "/auditions/" + roleID + "/" + s.Get("Email") + "/" + handler.Filename
uploader := s3manager.NewUploader(session.New())
result, err := uploader.Upload(&s3manager.UploadInput{
Body: file,
Bucket: aws.String("coaud"),
Key: aws.String(attachmentURL),
})
if err != nil {
log.Fatalln("Failed to upload", err)
}
log.Println("Successfully uploaded to", result.Location)
//create a new audition and add the link
auditionID := bson.NewObjectId()
audition := role.NewAudition(user.FindUser(s.Get("Email")), handler.Filename, result.Location, auditionID)
curRole := role.FindRole(roleID)
role.InsertAudition(audition, curRole)
w.Write([]byte("uploaded"))
} else {
w.Write([]byte("rejected"))
}
}
// UploadFile will upload file to specific S3 bucket
func UploadFile(session *session.Session, bucket, key string, file *os.File) {
service := s3manager.NewUploader(session)
resp, err := service.Upload(&s3manager.UploadInput{
Bucket: aws.String(bucket),
Key: aws.String(key),
Body: file,
ContentType: aws.String(getContentType(file)),
})
logger.Process(err, "Can't upload file")
fmt.Println("File was successfully uploaded! Location:", resp.Location)
}
func submitContestHandler(w http.ResponseWriter, r *http.Request) {
s := redis_session.Session(w, r)
contestId := bson.NewObjectId()
//s := redis_session.Session(w, r)
layout := "2006-01-02"
var UTC *time.Location = time.UTC
deadline, err := time.ParseInLocation(layout, r.FormValue("deadline"), UTC)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(r.FormFile("photo"))
file, handler, err := r.FormFile("photo")
if err == nil {
fmt.Println("success photo is in there")
defer file.Close()
//bytes, err := file.Seek(0,2)
if err != nil {
panic(err)
}
//var kilobytes int64
//kilobytes = (bytes / 1024)
//var megabytes float64
//megabytes = (float64)(kilobytes / 1024)
attachmentURL := "/contests/" + contestId.Hex() + "/" + s.Get("Email") + "/" + handler.Filename
uploader := s3manager.NewUploader(session.New())
result, err := uploader.Upload(&s3manager.UploadInput{
Body: file,
Bucket: aws.String("coaud"),
Key: aws.String(attachmentURL),
})
if err != nil {
log.Fatalln("Failed to upload", err)
}
newContest := role.NewContest(r.FormValue("title"), r.FormValue("description"), result.Location, deadline, contestId)
fmt.Println("Below this")
fmt.Println(result.Location)
role.InsertContest(newContest)
http.Redirect(w, r, "/contest/", http.StatusTemporaryRedirect)
} else {
fmt.Println("Default picture time")
newContest := role.NewContest(r.FormValue("title"), r.FormValue("description"), "/public/img/default_role_pic.png", deadline, contestId)
role.InsertContest(newContest)
http.Redirect(w, r, "/contest/", http.StatusTemporaryRedirect)
}
}
func TestBenchmarkBbs(t *testing.T) {
var lagerLogLevel lager.LogLevel
switch logLevel {
case DEBUG:
lagerLogLevel = lager.DEBUG
case INFO:
lagerLogLevel = lager.INFO
case ERROR:
lagerLogLevel = lager.ERROR
case FATAL:
lagerLogLevel = lager.FATAL
default:
panic(fmt.Errorf("unknown log level: %s", logLevel))
}
var logWriter io.Writer
if logFilename == "" {
logWriter = GinkgoWriter
} else {
logFile, err := os.Create(logFilename)
if err != nil {
panic(fmt.Errorf("Error opening file '%s': %s", logFilename, err.Error()))
}
defer logFile.Close()
logWriter = logFile
}
logger = lager.NewLogger("bbs-benchmarks-test")
logger.RegisterSink(lager.NewWriterSink(logWriter, lagerLogLevel))
reporters = []Reporter{}
if dataDogAPIKey != "" && dataDogAppKey != "" {
dataDogClient = datadog.NewClient(dataDogAPIKey, dataDogAppKey)
dataDogReporter = reporter.NewDataDogReporter(logger, metricPrefix, dataDogClient)
reporters = append(reporters, &dataDogReporter)
}
if awsAccessKeyID != "" && awsSecretAccessKey != "" && awsBucketName != "" {
creds := credentials.NewStaticCredentials(awsAccessKeyID, awsSecretAccessKey, "")
s3Client := s3.New(&aws.Config{
Region: &awsRegion,
Credentials: creds,
})
uploader := s3manager.NewUploader(&s3manager.UploadOptions{S3: s3Client})
reporter := reporter.NewS3Reporter(logger, awsBucketName, uploader)
reporters = append(reporters, &reporter)
}
RegisterFailHandler(Fail)
RunSpecsWithDefaultAndCustomReporters(t, "Benchmark BBS Suite", reporters)
}
func UploadVideo(Url string) (string, string, uint32, uint32, string) {
bucket := VideoBucket
defaults.DefaultConfig.Region = aws.String("us-east-1")
fileName := GenerateObjectId() + ".mp4"
fmt.Println("Downloading", Url, "to", fileName)
file, err := os.Create(fileName)
if err != nil {
fmt.Println("Error while creating", fileName, "-", err)
return "", "", 0, 0, ""
}
defer file.Close()
response, err := http.Get(Url)
if err != nil {
fmt.Println("Error while downloading", Url, "-", err)
return "", "", 0, 0, ""
}
defer response.Body.Close()
n, err := io.Copy(file, response.Body)
if err != nil {
fmt.Println("Error while downloading", Url, "-", err)
return "", "", 0, 0, ""
}
fmt.Println("n:%s", n)
dir, err := filepath.Abs(fileName)
if err != nil {
fmt.Println("error file Abs:%s\n", err)
}
fmt.Println(".......file path:%s\n", dir)
duration, timescale, durationstr, width, height := ExtractMp4Meta(dir)
fmt.Println("duaration:%d, timescale:%d, durationstr:%s, width:%d, height:%d", duration, timescale, durationstr, width, height)
fmt.Println("Start upload file to S3:%s\n", fileName)
uploader := s3manager.NewUploader(nil)
result, err := uploader.Upload(&s3manager.UploadInput{
Bucket: &bucket,
Key: &fileName,
Body: file,
})
if err != nil {
fmt.Println("Failed to upload", err)
}
fmt.Println("Uploaded....%s", result)
err = os.Remove(dir)
if err != nil {
}
// durstr := GetDuration(duration/timescale)
return VideoBucket, fileName, duration, timescale, durationstr
}
// Upload a local file to S3. Returns the s3 keyname of the
// uploaded item, or an error
func uploadLocalFileToS3(packagePath string, awsSession *session.Session, S3Bucket string, noop bool, logger *logrus.Logger) (string, error) {
// Query the S3 bucket for the bucket policies. The bucket _should_ have ObjectExpiration,
// otherwise we're just going to orphan our binaries...
err := ensureExpirationPolicy(awsSession, S3Bucket, noop, logger)
if nil != err {
return "", fmt.Errorf("Failed to ensure bucket policies: %s", err.Error())
}
// Then do the actual work
reader, err := os.Open(packagePath)
if nil != err {
return "", fmt.Errorf("Failed to open local archive for S3 upload: %s", err.Error())
}
defer func() {
reader.Close()
os.Remove(packagePath)
}()
body, err := os.Open(packagePath)
if nil != err {
return "", err
}
// Cache it in case there was an error & we need to cleanup
keyName := filepath.Base(packagePath)
uploadInput := &s3manager.UploadInput{
Bucket: &S3Bucket,
Key: &keyName,
ContentType: aws.String("application/zip"),
Body: body,
}
if noop {
logger.WithFields(logrus.Fields{
"Bucket": S3Bucket,
"Key": keyName,
}).Info("Bypassing S3 ZIP upload due to -n/-noop command line argument")
} else {
logger.WithFields(logrus.Fields{
"Source": packagePath,
}).Info("Uploading local file to S3")
uploader := s3manager.NewUploader(awsSession)
result, err := uploader.Upload(uploadInput)
if nil != err {
return "", err
}
logger.WithFields(logrus.Fields{
"URL": result.Location,
}).Info("Upload complete")
}
return keyName, nil
}
func TestUploadOrderReadFail2(t *testing.T) {
s, ops, _ := loggingSvc([]string{"UploadPart"})
mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s, Concurrency: 1})
_, err := mgr.Upload(&s3manager.UploadInput{
Bucket: aws.String("Bucket"),
Key: aws.String("Key"),
Body: &failreader{times: 2},
})
assert.Equal(t, "ReadRequestBody", err.(awserr.Error).Code())
assert.EqualError(t, err.(awserr.Error).OrigErr(), "random failure")
assert.Equal(t, []string{"CreateMultipartUpload", "AbortMultipartUpload"}, *ops)
}
func TestUploadOrderReadFail1(t *testing.T) {
s, ops, _ := loggingSvc(emptyList)
mgr := s3manager.NewUploader(&s3manager.UploadOptions{S3: s})
_, err := mgr.Upload(&s3manager.UploadInput{
Bucket: aws.String("Bucket"),
Key: aws.String("Key"),
Body: &failreader{times: 1},
})
assert.Equal(t, "ReadRequestBody", err.(awserr.Error).Code())
assert.EqualError(t, err.(awserr.Error).OrigErr(), "random failure")
assert.Equal(t, []string{}, *ops)
}
/*
Upload uploads a file to S3.
This is merely a wrapper around the aws-sdk-go uploader. It allows us to isolate
the aws-sdk-go dependencies and unify error handling.
*/
func Upload(file *os.File, bucket, key string) error {
uploader := s3manager.NewUploader(session.New(&aws.Config{Region: aws.String("us-east-1")}))
result, err := uploader.Upload(&s3manager.UploadInput{
Body: file,
Bucket: aws.String(bucket),
Key: aws.String(key),
})
if err != nil {
return err
}
log.Println("Successfully uploaded to", result.Location)
return nil
}
func Upload(conf *Config, file io.Reader, fileName string, isPNG bool) (string, error) {
s3Config := aws.NewConfig().
WithCredentials(credentials.NewStaticCredentials(conf.AccessKeyID, conf.SecretAccessKey, ""))
forcePathStyle := true
s3Config.S3ForcePathStyle = &forcePathStyle
if conf.AwsRegion == "" {
s3Config = s3Config.WithRegion(" ").WithEndpoint(conf.Endpoint)
} else {
s3Config = s3Config.WithRegion(conf.AwsRegion)
}
sess := session.New(s3Config)
uploader := s3manager.NewUploader(sess)
upParams := &s3manager.UploadInput{
ACL: aws.String("public-read"),
Bucket: &conf.BucketName,
Key: &fileName,
Body: file,
}
if isPNG {
upParams.ContentType = aws.String("image/png")
}
result, err := uploader.Upload(upParams)
if err != nil {
return "", fmt.Errorf("Failed to upload file, err: %s", err.Error())
}
return result.Location, nil
}
