Exemplo n.º 1
0
func (g *S3Upload) Upload() error {
	keys := s3.Keys{
		AccessKey: g.accessKey,
		SecretKey: g.secretKey,
	}
	urls := fmt.Sprintf("http://%s.s3.amazonaws.com/%s", g.bucket, g.path)

	body := bytes.NewReader(g.object)
	req, _ := http.NewRequest("PUT", urls, body)

	req.ContentLength = int64(body.Len())
	req.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	req.Header.Set("X-Amz-Acl", "public-read")
	req.Header.Set("Content-Type", g.getMimetype(g.path))
	s3.Sign(req, keys)

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}

	defer resp.Body.Close()

	return nil
}
Exemplo n.º 2
0
func (backend *S3Backend) Delete(hash string) error {
	r, err := http.NewRequest("DELETE", backend.key(hash), nil)
	if err != nil {
		return err
	}
	r.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	ks3.Sign(r, *backend.keys)
	_, err = http.DefaultClient.Do(r)
	return err
}
Exemplo n.º 3
0
func UploadToS3(upload S3Upload, client http.Client) error {
	url := fmt.Sprintf(
		"https://%s.s3.amazonaws.com%s", upload.Bucket, upload.Path,
	)

	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(upload.Content))
	if err != nil {
		return err
	}

	req.ContentLength = int64(len(upload.Content))
	req.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	if upload.ACL == "" {
		req.Header.Set("X-Amz-Acl", S3ACLPublicRead)
	} else {
		req.Header.Set("X-Amz-Acl", upload.ACL)
	}
	if upload.MimeType != "" {
		req.Header.Set("Content-Type", upload.MimeType)
	}

	// S3 does not support keep alive, and yet does not send "Connection: Close"
	// header as it should. I *think* in absence of this, go keeps the connection
	// half open. And one server we found a lot of connections in closed state,
	// leading to fd leak.
	req.Header.Set("Connection", "Close")

	s3.Sign(req, s3keys)

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}

	if res.StatusCode > 399 {
		return errors.New(
			fmt.Sprintf("Upload Failed: %d for %s.", res.StatusCode, url),
		)
	}

	_, err = io.Copy(ioutil.Discard, res.Body)
	if err != nil {
		return err
	}

	err = res.Body.Close()
	if err != nil {
		return err
	}

	log.Println("gutils.S3: Uploaded " + url)
	return nil
}
Exemplo n.º 4
0
func (backend *S3Backend) Exists(hash string) (bool, error) {
	r, err := http.NewRequest("HEAD", backend.key(hash), nil)
	r.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	ks3.Sign(r, *backend.keys)
	resp, err := http.DefaultClient.Do(r)
	if err != nil {
		return false, fmt.Errorf("S3Backend: error performing HEAD request for blob %v, err:%v", hash, err)
	}
	if resp.StatusCode == 200 {
		return true, nil
	}
	return false, nil
}
Exemplo n.º 5
0
func del(keys s3.Keys, path string) error {
	req, _ := http.NewRequest("DELETE", path, nil)
	req.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	s3.Sign(req, keys)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	resp.Body.Close()
	if resp.StatusCode >= 300 {
		return fmt.Errorf("delete %s returned status %d", path, resp.StatusCode)
	}
	return nil
}
Exemplo n.º 6
0
func get(keys s3.Keys, path string) (io.ReadCloser, error) {
	req, _ := http.NewRequest("GET", path, nil)
	req.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	s3.Sign(req, keys)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != 200 {
		resp.Body.Close()
		return nil, fmt.Errorf("get %s returned status %d", path, resp.StatusCode)
	}
	return resp.Body, nil
}
Exemplo n.º 7
0
func (backend *S3Backend) PlainText(hash string) ([]byte, error) {
	r, err := http.NewRequest("GET", backend.key(hash), nil)
	r.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	r.Header.Set("Range", fmt.Sprintf("bytes=0-85"))
	ks3.Sign(r, *backend.keys)
	resp, err := http.DefaultClient.Do(r)
	defer resp.Body.Close()
	res, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("S3Backend: error performing GET range request for blob %v, err:%v", hash, err)
	}
	if resp.StatusCode == 206 {
		return res, nil
	}
	return nil, fmt.Errorf("req failed %v: %s", resp.StatusCode, res)
}
Exemplo n.º 8
0
func s3put(bb *bytes.Buffer, url string) error {
	r, _ := http.NewRequest("PUT", url, bb)
	r.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	r.Header.Set("Content-Disposition", "attachment")
	r.Header.Set("X-Amz-Acl", "public-read")
	r.Header.Set("Content-Md5", b64md5(bb.Bytes()))
	s3.Sign(r, s3keys)
	resp, err := http.DefaultClient.Do(r)
	if err != nil {
		return err
	}
	if resp.StatusCode != 200 {
		body, _ := ioutil.ReadAll(resp.Body)
		return fmt.Errorf("s3 status %v putting %q: %q", resp.Status, url, string(body))
	}
	return nil
}
Exemplo n.º 9
0
func put(keys s3.Keys, path string, body []byte, header http.Header) error {
	req, _ := http.NewRequest("PUT", path, bytes.NewReader(body))
	req.ContentLength = int64(len(body))
	req.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	for k, v := range header {
		req.Header[k] = v
	}
	s3.Sign(req, keys)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	resp.Body.Close()
	if resp.StatusCode != 200 {
		return fmt.Errorf("put %s returned status %d", path, resp.StatusCode)
	}
	return nil
}
Exemplo n.º 10
0
func ExampleSign() {
	keys := s3.Keys{
		AccessKey: os.Getenv("S3_ACCESS_KEY"),
		SecretKey: os.Getenv("S3_SECRET_KEY"),
	}
	data := strings.NewReader("hello, world")
	r, _ := http.NewRequest("PUT", "https://example.s3.amazonaws.com/foo", data)
	r.ContentLength = int64(data.Len())
	r.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	r.Header.Set("X-Amz-Acl", "public-read")
	s3.Sign(r, keys)
	resp, err := http.DefaultClient.Do(r)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(resp.StatusCode)
}
Exemplo n.º 11
0
Arquivo: main.go Projeto: uriel/hk
func s3put(data []byte, filename string) (sha1 string, err error) {
	sha1 = string(b32sha1(data))
	url := s3url(sha1)
	r, _ := http.NewRequest("PUT", url, bytes.NewReader(data))
	r.ContentLength = int64(len(data))
	r.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	r.Header.Set("Content-Disposition", "attachment; filename="+filename)
	r.Header.Set("X-Amz-Acl", "public-read")
	r.Header.Set("Content-Md5", string(b16md5(data)))
	s3.Sign(r, s3keys)
	resp, err := http.DefaultClient.Do(r)
	if err != nil {
		return "", err
	}
	if resp.StatusCode != 200 {
		body, _ := ioutil.ReadAll(resp.Body)
		return "", fmt.Errorf("s3 status %v putting %q: %q", resp.Status, url, string(body))
	}
	return sha1, nil
}
Exemplo n.º 12
0
func (i *Image) getImageFromS3(AWSAccess string, AWSSecret string) (err error) {
	req, _ := http.NewRequest("GET", fmt.Sprintf("https://%v.s3.amazonaws.com/%v%v", i.Bucket, i.Path, i.FileName), nil)
	req.Header.Set("Date", time.Now().UTC().Format(http.TimeFormat))
	req.Header.Set("X-Amz-Acl", "public-read")
	s3.Sign(req, s3.Keys{
		AccessKey: AWSAccess,
		SecretKey: AWSSecret,
	})
	resp, err := http.DefaultClient.Do(req)
	if err == nil && resp.StatusCode == http.StatusOK {
		defer resp.Body.Close()
		i.Image, err = ioutil.ReadAll(resp.Body)
		if err != nil {
			fmt.Println(err)
		} else if i.Debug {
			fmt.Println("Retrieved image from from S3")
		}
		return nil
	} else if resp.StatusCode != http.StatusOK {
		err = errors.New("Error while making request")
	}
	return err
}