github.com/cloudfoundry-attic/ltc@v0.0.0-20151123212628-098adc7919fc/blob_store/dav_blob_store/blob_store.go

package dav_blob_store

import (
	"encoding/xml"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"path"
	"strings"
	"time"

	"github.com/cloudfoundry-incubator/bbs/models"
	"github.com/cloudfoundry-incubator/ltc/blob_store/blob"
	config_package "github.com/cloudfoundry-incubator/ltc/config"
)

type BlobStore struct {
	URL    *url.URL
	Client *http.Client
}

func New(config config_package.BlobStoreConfig) *BlobStore {
	return &BlobStore{
		URL: &url.URL{
			Scheme: "http",
			Host:   fmt.Sprintf("%s:%s", config.Host, config.Port),
			User:   url.UserPassword(config.Username, config.Password),
		},
		Client: http.DefaultClient,
	}
}

type xmlTime time.Time

func (t *xmlTime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	var v string
	d.DecodeElement(&v, &start)
	parse, err := time.Parse(time.RFC1123, v)
	if err != nil {
		return err
	}
	*t = xmlTime(parse)
	return nil
}

type listResponse struct {
	Responses []struct {
		HREF          string  `xml:"href"`
		LastModified  xmlTime `xml:"propstat>prop>getlastmodified"`
		ContentLength int64   `xml:"propstat>prop>getcontentlength"`
	} `xml:"response"`
}

func (b *BlobStore) List() ([]blob.Blob, error) {
	baseURL := &url.URL{
		Scheme: b.URL.Scheme,
		Host:   b.URL.Host,
		User:   b.URL.User,
		Path:   "/blobs",
	}

	req, err := http.NewRequest("PROPFIND", baseURL.String(), nil)
	if err != nil {
		return nil, err
	}

	req.Header.Add("Depth", "1")

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

	defer resp.Body.Close()

	if resp.StatusCode != 207 {
		return nil, errors.New(resp.Status)
	}

	decoder := xml.NewDecoder(resp.Body)

	var listResp listResponse
	if err := decoder.Decode(&listResp); err != nil {
		return nil, err
	}

	var blobFiles []blob.Blob
	for _, resp := range listResp.Responses {
		u, err := url.Parse(resp.HREF)
		if err != nil {
			return nil, err
		}

		if path.Clean(u.Path) == path.Clean(baseURL.Path) {
			continue
		}

		blobFiles = append(blobFiles, blob.Blob{
			Path:    strings.Replace(path.Clean(u.Path), "/blobs/", "", 1),
			Created: time.Time(resp.LastModified),
			Size:    resp.ContentLength,
		})
	}

	return blobFiles, nil
}

func (b *BlobStore) Upload(path string, contents io.ReadSeeker) error {
	baseURL := &url.URL{
		Scheme: b.URL.Scheme,
		Host:   b.URL.Host,
		User:   b.URL.User,
		Path:   "/blobs/" + path,
	}

	length, err := contents.Seek(0, 2)
	if err != nil {
		return err
	}
	contents.Seek(0, 0)

	req, err := http.NewRequest("PUT", baseURL.String(), contents)
	if err != nil {
		return err
	}

	req.ContentLength = length

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

	if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
		return errors.New(resp.Status)
	}

	return nil
}

func (b *BlobStore) Download(path string) (io.ReadCloser, error) {
	baseURL := &url.URL{
		Scheme: b.URL.Scheme,
		Host:   b.URL.Host,
		User:   b.URL.User,
		Path:   "/blobs/" + path,
	}

	req, err := http.NewRequest("GET", baseURL.String(), nil)
	if err != nil {
		return nil, err
	}

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

	if resp.StatusCode != http.StatusOK {
		return nil, errors.New(resp.Status)
	}

	return resp.Body, nil
}

func (b *BlobStore) Delete(path string) error {
	baseURL := &url.URL{
		Scheme: b.URL.Scheme,
		Host:   b.URL.Host,
		User:   b.URL.User,
		Path:   "/blobs/" + path,
	}

	req, err := http.NewRequest("DELETE", baseURL.String(), nil)
	if err != nil {
		return err
	}

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

	if resp.StatusCode != http.StatusNoContent {
		return errors.New(resp.Status)
	}

	return nil
}

func (b *BlobStore) DownloadAppBitsAction(dropletName string) *models.Action {
	return models.WrapAction(&models.DownloadAction{
		From:      b.URL.String() + "/blobs/" + dropletName + "-bits.zip",
		To:        "/tmp/app",
		User:      "vcap",
		LogSource: "DROPLET",
	})
}

func (b *BlobStore) DeleteAppBitsAction(dropletName string) *models.Action {
	return models.WrapAction(&models.RunAction{
		Path:      "/tmp/davtool",
		Dir:       "/",
		Args:      []string{"delete", b.URL.String() + "/blobs/" + dropletName + "-bits.zip"},
		User:      "vcap",
		LogSource: "DROPLET",
	})
}

func (b *BlobStore) UploadDropletAction(dropletName string) *models.Action {
	return models.WrapAction(&models.RunAction{
		Path:      "/tmp/davtool",
		Dir:       "/",
		Args:      []string{"put", b.URL.String() + "/blobs/" + dropletName + "-droplet.tgz", "/tmp/droplet"},
		User:      "vcap",
		LogSource: "DROPLET",
	})
}

func (b *BlobStore) DownloadDropletAction(dropletName string) *models.Action {
	return models.WrapAction(&models.DownloadAction{
		From:      b.URL.String() + "/blobs/" + dropletName + "-droplet.tgz",
		To:        "/home/vcap",
		User:      "vcap",
		LogSource: "DROPLET",
	})
}