vagrant-bosh 0.0.6 → 0.0.7

data/go/src/boshprovisioner/deployment/manifest/watch_time.go

@@ -1,43 +0,0 @@
-package manifest
-
-import (
-	"strconv"
-	"strings"
-
-	bosherr "bosh/errors"
-)
-
-type WatchTime [2]int
-
-func NewWatchTimeFromString(str string) (WatchTime, error) {
-	var watchTime WatchTime
-
-	parts := strings.Split(str, "-")
-	if len(parts) != 2 {
-		return watchTime, bosherr.New("Invalid watch time range %s", str)
-	}
-
-	min, err := strconv.Atoi(strings.Trim(parts[0], " "))
-	if err != nil {
-		return watchTime, bosherr.WrapError(
-			err, "Non-positive number as watch time minimum %s", parts[0])
-	}
-
-	max, err := strconv.Atoi(strings.Trim(parts[1], " "))
-	if err != nil {
-		return watchTime, bosherr.WrapError(
-			err, "Non-positive number as watch time maximum %s", parts[1])
-	}
-
-	if max < min {
-		return watchTime, bosherr.New(
-			"Watch time must have maximum greater than or equal minimum %s", str)
-	}
-
-	watchTime[0], watchTime[1] = min, max
-
-	return watchTime, nil
-}
-
-func (wt WatchTime) Start() int { return wt[0] }
-func (wt WatchTime) End() int   { return wt[1] }

data/go/src/boshprovisioner/deployment/manifest_reader.go

@@ -1,46 +0,0 @@
-package deployment
-
-import (
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-
-	bpdepman "boshprovisioner/deployment/manifest"
-)
-
-type ManifestReader struct {
-	path   string
-	fs     boshsys.FileSystem
-	logger boshlog.Logger
-}
-
-func NewManifestReader(
-	path string,
-	fs boshsys.FileSystem,
-	logger boshlog.Logger,
-) ManifestReader {
-	return ManifestReader{path: path, fs: fs, logger: logger}
-}
-
-func (r ManifestReader) Read() (Deployment, error) {
-	var deployment Deployment
-
-	manifest, err := bpdepman.NewManifestFromPath(r.path, r.fs)
-	if err != nil {
-		return deployment, bosherr.WrapError(err, "Reading manifest")
-	}
-
-	deployment.populateFromManifest(manifest)
-
-	// todo pass by ref?
-	err = NewSemanticValidator(deployment).Validate()
-	if err != nil {
-		return deployment, bosherr.WrapError(err, "Validating deployment semantically")
-	}
-
-	return deployment, nil
-}
-
-func (r ManifestReader) Close() error {
-	return nil
-}

data/go/src/boshprovisioner/deployment/reader_factory.go

@@ -1,25 +0,0 @@
-package deployment
-
-import (
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-)
-
-type ReaderFactory struct {
-	fs     boshsys.FileSystem
-	logger boshlog.Logger
-}
-
-func NewReaderFactory(
-	fs boshsys.FileSystem,
-	logger boshlog.Logger,
-) ReaderFactory {
-	return ReaderFactory{
-		fs:     fs,
-		logger: logger,
-	}
-}
-
-func (rf ReaderFactory) NewManifestReader(path string) ManifestReader {
-	return NewManifestReader(path, rf.fs, rf.logger)
-}

data/go/src/boshprovisioner/deployment/semantic_validator.go

@@ -1,111 +0,0 @@
-package deployment
-
-import (
-	bosherr "bosh/errors"
-)
-
-// SemanticValidator validates deployment to determine if it represents a meaningful state.
-// e.g. - is each job template associated with a release?
-//      - are there enough static ips for each job instance?
-type SemanticValidator struct {
-	deployment Deployment
-}
-
-func NewSemanticValidator(deployment Deployment) SemanticValidator {
-	return SemanticValidator{deployment: deployment}
-}
-
-func (v SemanticValidator) Validate() error {
-	for _, net := range v.deployment.Networks {
-		err := v.validateNetwork(net)
-		if err != nil {
-			return bosherr.WrapError(err, "Network %s", net.Name)
-		}
-	}
-
-	for _, release := range v.deployment.Releases {
-		err := v.validateRelease(release)
-		if err != nil {
-			return bosherr.WrapError(err, "Release %s", release.Name)
-		}
-	}
-
-	err := v.validateInstance(v.deployment.CompilationInstance)
-	if err != nil {
-		return bosherr.WrapError(err, "Compilation instance")
-	}
-
-	for _, job := range v.deployment.Jobs {
-		err := v.validateJob(job)
-		if err != nil {
-			return bosherr.WrapError(err, "Job %s", job.Name)
-		}
-	}
-
-	return nil
-}
-
-func (v SemanticValidator) validateNetwork(network Network) error {
-	if network.Type == NetworkTypeManual {
-		return bosherr.New("Manual networking is not supported")
-	}
-
-	return nil
-}
-
-func (v SemanticValidator) validateRelease(release Release) error {
-	if release.Version == "latest" {
-		return bosherr.New("Version 'latest' is not supported")
-	}
-
-	return nil
-}
-
-func (v SemanticValidator) validateJob(job Job) error {
-	for _, template := range job.Templates {
-		err := v.validateTemplate(template)
-		if err != nil {
-			return bosherr.WrapError(err, "Template %s", template.Name)
-		}
-	}
-
-	for _, instance := range job.Instances {
-		err := v.validateInstance(instance)
-		if err != nil {
-			return bosherr.WrapError(err, "Instance %d", instance.Index)
-		}
-	}
-
-	return nil
-}
-
-func (v SemanticValidator) validateTemplate(template Template) error {
-	if template.Release == nil {
-		return bosherr.New("Missing associated release")
-	}
-
-	return nil
-}
-
-func (v SemanticValidator) validateInstance(instance Instance) error {
-	for i, na := range instance.NetworkAssociations {
-		err := v.validateNetworkAssociation(na)
-		if err != nil {
-			return bosherr.WrapError(err, "Network association %d", i)
-		}
-	}
-
-	return nil
-}
-
-func (v SemanticValidator) validateNetworkAssociation(na NetworkAssociation) error {
-	if na.Network == nil {
-		return bosherr.New("Missing associated network")
-	}
-
-	if na.MustHaveStaticIP && na.StaticIP == nil {
-		return bosherr.New("Missing static IP assignment")
-	}
-
-	return nil
-}

data/go/src/boshprovisioner/downloader/blobstore_downloader.go

@@ -1,55 +0,0 @@
-package downloader
-
-import (
-	gourl "net/url"
-
-	boshblob "bosh/blobstore"
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-)
-
-const blobstoreDownloaderLogTag = "BlobstoreDownloader"
-
-type BlobstoreDownloader struct {
-	blobstore boshblob.Blobstore
-	logger    boshlog.Logger
-}
-
-func NewBlobstoreDownloader(
-	blobstore boshblob.Blobstore,
-	logger boshlog.Logger,
-) BlobstoreDownloader {
-	return BlobstoreDownloader{
-		blobstore: blobstore,
-		logger:    logger,
-	}
-}
-
-// Download takes URL of format blobstore:///blobId?fingerprint=sha1-value
-func (d BlobstoreDownloader) Download(url string) (string, error) {
-	parsedURL, err := gourl.Parse(url)
-	if err != nil {
-		return "", bosherr.WrapError(err, "Parsing url %s", url)
-	}
-
-	var fingerprint string
-
-	if fingerprints, found := parsedURL.Query()["fingerprint"]; found {
-		if len(fingerprints) > 0 {
-			fingerprint = fingerprints[0]
-		}
-	}
-
-	path, err := d.blobstore.Get(parsedURL.Path, fingerprint)
-	if err != nil {
-		return "", bosherr.WrapError(err, "Downloading blob")
-	}
-
-	d.logger.Debug(blobstoreDownloaderLogTag, "Downloaded %s to %s", url, path)
-
-	return path, nil
-}
-
-func (d BlobstoreDownloader) CleanUp(path string) error {
-	return d.blobstore.CleanUp(path)
-}

data/go/src/boshprovisioner/downloader/default_mux_downloader.go

@@ -1,22 +0,0 @@
-package downloader
-
-import (
-	boshblob "bosh/blobstore"
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-)
-
-func NewDefaultMuxDownloader(
-	blobstore boshblob.Blobstore,
-	fs boshsys.FileSystem,
-	logger boshlog.Logger,
-) MuxDownloader {
-	mux := map[string]Downloader{
-		"http":      NewHTTPDownloader(fs, logger),
-		"https":     NewHTTPDownloader(fs, logger),
-		"file":      NewLocalFSDownloader(fs, logger),
-		"blobstore": NewBlobstoreDownloader(blobstore, logger),
-	}
-
-	return NewMuxDownloader(mux, logger)
-}

data/go/src/boshprovisioner/downloader/downloader_interface.go

@@ -1,6 +0,0 @@
-package downloader
-
-type Downloader interface {
-	Download(string) (string, error)
-	CleanUp(string) error
-}

data/go/src/boshprovisioner/downloader/http_downloader.go

@@ -1,53 +0,0 @@
-package downloader
-
-import (
-	"io"
-	"net/http"
-
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-)
-
-const httpDownloaderLogTag = "HTTPDownloader"
-
-type HTTPDownloader struct {
-	fs     boshsys.FileSystem
-	logger boshlog.Logger
-}
-
-func NewHTTPDownloader(
-	fs boshsys.FileSystem,
-	logger boshlog.Logger,
-) HTTPDownloader {
-	return HTTPDownloader{fs: fs, logger: logger}
-}
-
-func (d HTTPDownloader) Download(url string) (string, error) {
-	file, err := d.fs.TempFile("release-Downloader-HTTPDownloader")
-	if err != nil {
-		return "", bosherr.WrapError(err, "Creating download destination")
-	}
-
-	d.logger.Debug(httpDownloaderLogTag, "Downloaded %s to %s", url, file.Name())
-
-	defer file.Close()
-
-	resp, err := http.Get(url)
-	if err != nil {
-		return "", bosherr.WrapError(err, "Get url")
-	}
-
-	defer resp.Body.Close()
-
-	_, err = io.Copy(file, resp.Body)
-	if err != nil {
-		return "", bosherr.WrapError(err, "Copying response to file")
-	}
-
-	return file.Name(), nil
-}
-
-func (d HTTPDownloader) CleanUp(path string) error {
-	return d.fs.RemoveAll(path)
-}

data/go/src/boshprovisioner/downloader/local_fs_downloader.go

@@ -1,48 +0,0 @@
-package downloader
-
-import (
-	"strings"
-
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-)
-
-const localFSDownloaderLogTag = "LocalFSDownloader"
-
-type LocalFSDownloader struct {
-	fs     boshsys.FileSystem
-	logger boshlog.Logger
-}
-
-func NewLocalFSDownloader(
-	fs boshsys.FileSystem,
-	logger boshlog.Logger,
-) LocalFSDownloader {
-	return LocalFSDownloader{fs: fs, logger: logger}
-}
-
-func (d LocalFSDownloader) Download(url string) (string, error) {
-	file, err := d.fs.TempFile("downloader-LocalFSDownloader")
-	if err != nil {
-		return "", bosherr.WrapError(err, "Creating download destination")
-	}
-
-	d.logger.Debug(localFSDownloaderLogTag, "Downloaded %s to %s", url, file.Name())
-
-	err = file.Close()
-	if err != nil {
-		return "", bosherr.WrapError(err, "Closing download destination")
-	}
-
-	err = d.fs.CopyFile(strings.TrimPrefix(url, "file://"), file.Name())
-	if err != nil {
-		return "", bosherr.WrapError(err, "Copying to destination")
-	}
-
-	return file.Name(), nil
-}
-
-func (d LocalFSDownloader) CleanUp(path string) error {
-	return d.fs.RemoveAll(path)
-}

data/go/src/boshprovisioner/downloader/mux_downloader.go

@@ -1,69 +0,0 @@
-package downloader
-
-import (
-	"strings"
-
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-)
-
-const muxDownloaderLogTag = "Downloader"
-
-type MuxDownloader struct {
-	// e.g. {"http": NewHTTPDownloader()}
-	mux map[string]Downloader
-
-	logger boshlog.Logger
-
-	// Track which Downloader should be used to clean up
-	downloadedPaths map[string]Downloader
-}
-
-func NewMuxDownloader(
-	mux map[string]Downloader,
-	logger boshlog.Logger,
-) MuxDownloader {
-	return MuxDownloader{
-		mux:    mux,
-		logger: logger,
-
-		downloadedPaths: map[string]Downloader{},
-	}
-}
-
-func (d MuxDownloader) Download(url string) (string, error) {
-	for prefix, downloader := range d.mux {
-		if strings.HasPrefix(url, prefix+"://") {
-			path, err := downloader.Download(url)
-			if err != nil {
-				return path, err
-			}
-
-			// Only remember path if Downloader succeeded
-			d.downloadedPaths[path] = downloader
-
-			return path, err
-		}
-	}
-
-	return "", bosherr.New("URL %s without matching downloader", url)
-}
-
-func (d MuxDownloader) CleanUp(path string) error {
-	downloader, ok := d.downloadedPaths[path]
-	if !ok {
-		// programmer error
-		return bosherr.New("Unknown path %s requested to be cleaned up", path)
-	}
-
-	err := downloader.CleanUp(path)
-	if err != nil {
-		return err
-	}
-
-	// Forget path only if associated Downloader succeeded cleaning up
-	// so that CleanUp could be called multiple times
-	delete(d.downloadedPaths, path)
-
-	return nil
-}