vagrant-bosh 0.0.1

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

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,22 @@
+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

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

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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,48 @@
+package downloader
+
+import (
+	"strings"
+
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+)
+
+const localFSDownloaderLogTag = "Downloader"
+
+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

@@ -0,0 +1,69 @@
+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
+}

data/go/src/boshprovisioner/eventlog/log.go

@@ -0,0 +1,72 @@
+package eventlog
+
+import (
+	"encoding/json"
+	"io"
+	"os"
+
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+)
+
+const logLogTag = "Log"
+
+type Log struct {
+	writer io.Writer
+	logger boshlog.Logger
+}
+
+type logEntry struct {
+	Time int64 `json:"time"`
+
+	Stage string   `json:"stage"`
+	Task  string   `json:"task"`
+	Tags  []string `json:"tags"`
+
+	Total int `json:"total"`
+	Index int `json:"index"`
+
+	State    string `json:"state"`
+	Progress int    `json:"progress"`
+
+	// Might contain error key
+	Data map[string]interface{} `json:"data,omitempty"`
+}
+
+func NewLog(logger boshlog.Logger) Log {
+	return Log{
+		writer: os.Stdout,
+		logger: logger,
+	}
+}
+
+func (l Log) BeginStage(name string, total int) *Stage {
+	return &Stage{
+		log:   l,
+		name:  name,
+		total: total,
+	}
+}
+
+func (l Log) writeLogEntryNoErr(entry logEntry) {
+	err := l.writeLogEntry(entry)
+	if err != nil {
+		l.logger.Error(logLogTag, "Failed writing log entry %s", err.Error())
+	}
+}
+
+func (l Log) writeLogEntry(entry logEntry) error {
+	bytes, err := json.Marshal(entry)
+	if err != nil {
+		return bosherr.WrapError(err, "Marshalling log entry")
+	}
+
+	bytes = append(bytes, []byte("\n")...)
+
+	_, err = l.writer.Write(bytes)
+	if err != nil {
+		return bosherr.WrapError(err, "Writing log entry")
+	}
+
+	return nil
+}

data/go/src/boshprovisioner/eventlog/stage.go

@@ -0,0 +1,39 @@
+package eventlog
+
+import (
+	"sync"
+)
+
+type Stage struct {
+	log Log
+
+	name string
+
+	total         int
+	currTaskIndex int
+
+	indexLock sync.Mutex
+}
+
+func (s *Stage) BeginTask(name string) Task {
+	s.indexLock.Lock()
+
+	index := s.currTaskIndex
+	s.currTaskIndex++
+
+	s.indexLock.Unlock()
+
+	task := Task{
+		log: s.log,
+
+		stageName: s.name,
+		name:      name,
+
+		total: s.total,
+		index: index,
+	}
+
+	task.Start()
+
+	return task
+}

data/go/src/boshprovisioner/eventlog/task.go

@@ -0,0 +1,58 @@
+package eventlog
+
+import (
+	"time"
+)
+
+type Task struct {
+	log Log
+
+	stageName string
+	name      string
+
+	total int
+	index int
+}
+
+func (t Task) Start() {
+	entry := logEntry{
+		Time: time.Now().Unix(),
+
+		Stage: t.stageName,
+		Task:  t.name,
+
+		Total: t.total,
+		Index: t.index,
+
+		State:    "started",
+		Progress: 0,
+	}
+
+	t.log.writeLogEntryNoErr(entry)
+}
+
+func (t Task) End(err error) error {
+	entry := logEntry{
+		Time: time.Now().Unix(),
+
+		Stage: t.stageName,
+		Task:  t.name,
+
+		Total: t.total,
+		Index: t.index,
+
+		State:    "finished",
+		Progress: 100,
+	}
+
+	if err != nil {
+		entry.State = "failed"
+		entry.Data = map[string]interface{}{
+			"error": err.Error(),
+		}
+	}
+
+	t.log.writeLogEntryNoErr(entry)
+
+	return err
+}