func (rm *rmOpts) Execute(args []string) error {
k, err := getAWSKeys()
if err != nil {
return err
}
conf := new(s3gof3r.Config)
*conf = *s3gof3r.DefaultConfig
s3 := s3gof3r.New(rm.EndPoint, k)
s3gof3r.SetLogger(os.Stderr, "", log.Ltime, rm.Debug)
// parse positional cp args
if len(args) != 1 {
return fmt.Errorf("rm: path argument required")
}
//var urls [1]*url.URL
u, err := url.Parse(args[0])
if err != nil {
return fmt.Errorf("parse error: %s", err)
}
if u.Host != "" && u.Scheme != "s3" {
return fmt.Errorf("parse error: %s", u.String())
}
return s3.Bucket(u.Host).Delete(u.Path)
}
func main() {
log.SetFlags(0) // hide timestamps from Go logs
parseFlags()
resultBucketName = os.Getenv("RESULT_STORAGE_BUCKET")
if resultBucketName != "" {
keys, err := s3gof3r.EnvKeys()
if err != nil {
log.Fatal(err)
}
resultBucket = s3gof3r.New(s3gof3r.DefaultDomain, keys).Bucket(resultBucketName)
resultBucket.Concurrency = 4
resultBucket.PartSize = int64(2 * MB)
resultBucket.Md5Check = false
httpClient = resultBucket.Client
if rrs := os.Getenv("USE_RRS"); rrs == "true" || rrs == "1" {
useRRS = true
}
}
router := httprouter.New()
router.HEAD("/:signature/:size/*source", handleResize)
router.GET("/:signature/:size/*source", handleResize)
log.Fatal(http.ListenAndServe(listenInterface, router))
}
func (cp *cpOpts) Execute(args []string) (err error) {
k, err := getAWSKeys()
if err != nil {
return
}
conf := new(s3gof3r.Config)
*conf = *s3gof3r.DefaultConfig
s3 := s3gof3r.New(cp.EndPoint, k)
conf.Concurrency = cp.Concurrency
if cp.NoSSL {
conf.Scheme = "http"
}
conf.PartSize = cp.PartSize
conf.Md5Check = !cp.NoMd5
s3gof3r.SetLogger(os.Stderr, "", log.LstdFlags, cp.Debug)
src, err := func(src string) (io.ReadCloser, error) {
u, err := url.Parse(src)
if err != nil {
return nil, fmt.Errorf("parse error: %s", err)
}
if u.Host == "" {
return os.Open(u.Path)
}
r, _, err := s3.Bucket(u.Host).GetReader(u.Path, conf)
return r, err
}(cp.Source)
if err != nil {
return
}
defer checkClose(src, err)
dst, err := func(dst string) (io.WriteCloser, error) {
u, err := url.Parse(dst)
if err != nil {
return nil, fmt.Errorf("parse error: %s", err)
}
if u.Host == "" {
return os.Create(u.Path)
}
return s3.Bucket(u.Host).PutWriter(u.Path, ACL(cp.Header, cp.ACL), conf)
}(cp.Dest)
if err != nil {
return
}
defer checkClose(dst, err)
_, err = io.Copy(dst, src)
return
}
func (get *getOpts) Execute(args []string) (err error) {
conf := new(s3gof3r.Config)
*conf = *s3gof3r.DefaultConfig
k, err := getAWSKeys()
if err != nil {
return
}
s3 := s3gof3r.New(get.EndPoint, k)
b := s3.Bucket(get.Bucket)
conf.Concurrency = get.Concurrency
if get.NoSSL {
conf.Scheme = "http"
}
conf.PartSize = get.PartSize
conf.Md5Check = !get.NoMd5
s3gof3r.SetLogger(os.Stderr, "", log.LstdFlags, get.Debug)
if get.VersionID != "" {
get.Key = fmt.Sprintf("%s?versionId=%s", get.Key, get.VersionID)
}
w, err := os.Create(get.Path)
if err != nil {
if get.Path == "" {
w = os.Stdout
} else {
return
}
}
defer checkClose(w, err)
r, header, err := b.GetReader(get.Key, conf)
if err != nil {
return
}
defer checkClose(r, err)
if _, err = io.Copy(w, r); err != nil {
return
}
if get.Debug {
log.Println("Headers: ", header)
}
return
}
func (put *putOpts) Execute(args []string) (err error) {
conf := new(s3gof3r.Config)
*conf = *s3gof3r.DefaultConfig
k, err := getAWSKeys()
if err != nil {
return
}
s3 := s3gof3r.New(put.EndPoint, k)
b := s3.Bucket(put.Bucket)
conf.Concurrency = put.Concurrency
if put.NoSSL {
conf.Scheme = "http"
}
conf.PartSize = put.PartSize
conf.Md5Check = !put.NoMd5
s3gof3r.SetLogger(os.Stderr, "", log.LstdFlags, put.Debug)
if put.Header == nil {
put.Header = make(http.Header)
}
r, err := os.Open(put.Path)
if err != nil {
if put.Path == "" {
r = os.Stdin
} else {
return
}
}
defer checkClose(r, err)
w, err := b.PutWriter(put.Key, ACL(put.Header, put.ACL), conf)
if err != nil {
return
}
defer checkClose(w, err)
if _, err = io.Copy(w, r); err != nil {
return
}
return
}