vagrant-bosh 0.0.6 → 0.0.7

data/go/src/boshprovisioner/index/file_index_test.go

@@ -1,296 +0,0 @@
-package index_test
-
-import (
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	. "boshprovisioner/index"
-)
-
-type Key struct {
-	Key string
-}
-
-type Value struct {
-	Name  string
-	Count float64
-}
-
-type ArrayValue struct{ Names []string }
-
-type StructValue struct{ Name Name }
-
-type Name struct {
-	First string
-	Last  string
-}
-
-var _ = Describe("FileIndex", func() {
-	var (
-		index FileIndex
-	)
-
-	BeforeEach(func() {
-		logger := boshlog.NewLogger(boshlog.LevelNone)
-		fs := boshsys.NewOsFileSystem(logger)
-
-		file, err := fs.TempFile("file-index")
-		Expect(err).ToNot(HaveOccurred())
-
-		err = fs.RemoveAll(file.Name())
-		Expect(err).ToNot(HaveOccurred())
-
-		index = NewFileIndex(file.Name(), fs)
-	})
-
-	Describe("Save/List", func() {
-		It("returns list of saved items", func() {
-			k1 := Key{Key: "key-1"}
-			v1 := Value{Name: "value-1", Count: 1}
-			err := index.Save(k1, v1)
-			Expect(err).ToNot(HaveOccurred())
-
-			k2 := Key{Key: "key-2"}
-			v2 := Value{Name: "value-2", Count: 2}
-			err = index.Save(k2, v2)
-			Expect(err).ToNot(HaveOccurred())
-
-			var values []Value
-
-			err = index.List(&values)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(values).To(Equal([]Value{v1, v2}))
-		})
-
-		Describe("array values", func() {
-			It("returns list of saved items that have nil, 0, 1, and more items in an array", func() {
-				k1 := Key{Key: "key-1"}
-				v1 := ArrayValue{Names: []string{"name-1-1", "name-1-2"}} // multiple
-				err := index.Save(k1, v1)
-				Expect(err).ToNot(HaveOccurred())
-
-				k2 := Key{Key: "key-2"}
-				v2 := ArrayValue{Names: []string{"name-2-1"}} // single
-				err = index.Save(k2, v2)
-				Expect(err).ToNot(HaveOccurred())
-
-				k3 := Key{Key: "key-3"}
-				v3 := ArrayValue{Names: []string{}} // empty slice
-				err = index.Save(k3, v3)
-				Expect(err).ToNot(HaveOccurred())
-
-				k4 := Key{Key: "key-4"}
-				v4 := ArrayValue{} // nil
-				err = index.Save(k4, v4)
-				Expect(err).ToNot(HaveOccurred())
-
-				var values []ArrayValue
-
-				err = index.List(&values)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(values).To(Equal([]ArrayValue{v1, v2, v3, v4}))
-			})
-		})
-
-		Describe("struct values", func() {
-			It("returns list of saved items that have nil or more item", func() {
-				k1 := Key{Key: "key-1"}
-				v1 := StructValue{Name: Name{First: "first-name-1", Last: "last-name-1"}} // struct
-				err := index.Save(k1, v1)
-				Expect(err).ToNot(HaveOccurred())
-
-				k2 := Key{Key: "key-2"}
-				v2 := StructValue{Name: Name{First: "first-name-1"}} // struct incomplete
-				err = index.Save(k2, v2)
-				Expect(err).ToNot(HaveOccurred())
-
-				k3 := Key{Key: "key-3"}
-				v3 := StructValue{} // zero value
-				err = index.Save(k3, v3)
-				Expect(err).ToNot(HaveOccurred())
-
-				var values []StructValue
-
-				err = index.List(&values)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(values).To(Equal([]StructValue{v1, v2, v3}))
-			})
-		})
-	})
-
-	Describe("Save/ListKeys", func() {
-		It("returns list of saved keys", func() {
-			k1 := Key{Key: "key-1"}
-			v1 := Value{Name: "value-1", Count: 1}
-			err := index.Save(k1, v1)
-			Expect(err).ToNot(HaveOccurred())
-
-			k2 := Key{Key: "key-2"}
-			v2 := Value{Name: "value-2", Count: 2}
-			err = index.Save(k2, v2)
-			Expect(err).ToNot(HaveOccurred())
-
-			var keys []Key
-
-			err = index.ListKeys(&keys)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(keys).To(Equal([]Key{k1, k2}))
-		})
-	})
-
-	Describe("Save/Find", func() {
-		It("returns true if item is found by key", func() {
-			k1 := Key{Key: "key-1"}
-			v1 := Value{Name: "value-1", Count: 1}
-			err := index.Save(k1, v1)
-			Expect(err).ToNot(HaveOccurred())
-
-			var value Value
-
-			err = index.Find(k1, &value)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(err).ToNot(Equal(ErrNotFound))
-
-			Expect(value).To(Equal(v1))
-		})
-
-		It("returns false if item is not found by key", func() {
-			k1 := Key{Key: "key-1"}
-			v1 := Value{Name: "value-1", Count: 1}
-			err := index.Save(k1, v1)
-			Expect(err).ToNot(HaveOccurred())
-
-			var value Value
-
-			err = index.Find(Key{Key: "key-2"}, &value)
-			Expect(err).To(HaveOccurred())
-			Expect(err).To(Equal(ErrNotFound))
-
-			Expect(value).To(Equal(Value{}))
-		})
-
-		Describe("array values", func() {
-			It("returns true and correctly deserializes item with nil", func() {
-				k1 := Key{Key: "key-1"}
-				v1 := ArrayValue{} // nil
-				err := index.Save(k1, v1)
-				Expect(err).ToNot(HaveOccurred())
-
-				var value ArrayValue
-
-				err = index.Find(k1, &value)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(err).ToNot(Equal(ErrNotFound))
-
-				Expect(value).To(Equal(v1))
-			})
-
-			It("returns true and correctly deserializes item with empty slice", func() {
-				k1 := Key{Key: "key-1"}
-				v1 := ArrayValue{Names: []string{}} // empty slice
-				err := index.Save(k1, v1)
-				Expect(err).ToNot(HaveOccurred())
-
-				var value ArrayValue
-
-				err = index.Find(k1, &value)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(err).ToNot(Equal(ErrNotFound))
-
-				Expect(value).To(Equal(v1))
-			})
-
-			It("returns true and correctly deserializes item with multiple items", func() {
-				k1 := Key{Key: "key-1"}
-				v1 := ArrayValue{Names: []string{"name-1-1", "name-1-2"}} // multiple
-				err := index.Save(k1, v1)
-				Expect(err).ToNot(HaveOccurred())
-
-				var value ArrayValue
-
-				err = index.Find(k1, &value)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(err).ToNot(Equal(ErrNotFound))
-
-				Expect(value).To(Equal(v1))
-			})
-		})
-
-		Describe("struct values", func() {
-			It("returns true and correctly deserializes item with zero value", func() {
-				k1 := Key{Key: "key-1"}
-				v1 := StructValue{} // zero value
-				err := index.Save(k1, v1)
-				Expect(err).ToNot(HaveOccurred())
-
-				var value StructValue
-
-				err = index.Find(k1, &value)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(err).ToNot(Equal(ErrNotFound))
-
-				Expect(value).To(Equal(v1))
-			})
-
-			It("returns true and correctly deserializes item with filled struct", func() {
-				k1 := Key{Key: "key-1"}
-				v1 := StructValue{Name: Name{First: "first-name-1", Last: "last-name-1"}} // struct
-				err := index.Save(k1, v1)
-				Expect(err).ToNot(HaveOccurred())
-
-				var value StructValue
-
-				err = index.Find(k1, &value)
-				Expect(err).ToNot(HaveOccurred())
-				Expect(err).ToNot(Equal(ErrNotFound))
-
-				Expect(value).To(Equal(v1))
-			})
-		})
-	})
-
-	Describe("Save/Remove", func() {
-		var (
-			k1 Key
-			v1 Value
-		)
-
-		BeforeEach(func() {
-			k1 = Key{Key: "key-1"}
-			v1 = Value{Name: "value-1", Count: 1}
-			err := index.Save(k1, v1)
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("removes matching value if found", func() {
-			k2 := Key{Key: "key-2"}
-			v2 := Value{Name: "value-2", Count: 2}
-			err := index.Save(k2, v2)
-			Expect(err).ToNot(HaveOccurred())
-
-			err = index.Remove(k1)
-			Expect(err).ToNot(HaveOccurred())
-
-			var values []Value
-
-			err = index.List(&values)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(values).To(Equal([]Value{v2}))
-		})
-
-		It("does not remove non-matching value if not found", func() {
-			k2 := Key{Key: "key-2"}
-
-			err := index.Remove(k2)
-			Expect(err).ToNot(HaveOccurred())
-
-			var values []Value
-
-			err = index.List(&values)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(values).To(Equal([]Value{v1}))
-		})
-	})
-})

data/go/src/boshprovisioner/index/index_interface.go

@@ -1,18 +0,0 @@
-package index
-
-import (
-	"errors"
-)
-
-var (
-	ErrNotFound = errors.New("Record is not found")
-)
-
-type Index interface {
-	ListKeys(interface{}) error
-	List(interface{}) error
-
-	Find(interface{}, interface{}) error
-	Save(interface{}, interface{}) error
-	Remove(interface{}) error
-}

data/go/src/boshprovisioner/index/index_suite_test.go

@@ -1,13 +0,0 @@
-package index_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestIndex(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Index Suite")
-}

data/go/src/boshprovisioner/instance/instance.go

@@ -1,43 +0,0 @@
-package instance
-
-import (
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-
-	bpdep "boshprovisioner/deployment"
-	bpinstupd "boshprovisioner/instance/updater"
-)
-
-type Instance struct {
-	updater bpinstupd.Updater
-
-	job         bpdep.Job
-	depInstance bpdep.Instance
-
-	logger boshlog.Logger
-}
-
-func NewInstance(
-	updater bpinstupd.Updater,
-	job bpdep.Job,
-	depInstance bpdep.Instance,
-	logger boshlog.Logger,
-) Instance {
-	return Instance{
-		updater:     updater,
-		job:         job,
-		depInstance: depInstance,
-		logger:      logger,
-	}
-}
-
-func (i Instance) Deprovision() error {
-	i.logger.Debug(instanceProvisionerLogTag, "Tearing down instance")
-
-	err := i.updater.TearDown()
-	if err != nil {
-		return bosherr.WrapError(err, "Tearing down instance %d", i.depInstance.Index)
-	}
-
-	return nil
-}

data/go/src/boshprovisioner/instance/instance_provisioner.go

@@ -1,48 +0,0 @@
-package instance
-
-import (
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-
-	bpagclient "boshprovisioner/agent/client"
-	bpdep "boshprovisioner/deployment"
-	bpinstupd "boshprovisioner/instance/updater"
-)
-
-const instanceProvisionerLogTag = "InstanceProvisioner"
-
-type InstanceProvisioner struct {
-	instanceUpdaterFactory bpinstupd.UpdaterFactory
-	logger                 boshlog.Logger
-}
-
-func NewInstanceProvisioner(
-	instanceUpdaterFactory bpinstupd.UpdaterFactory,
-	logger boshlog.Logger,
-) InstanceProvisioner {
-	return InstanceProvisioner{
-		instanceUpdaterFactory: instanceUpdaterFactory,
-		logger:                 logger,
-	}
-}
-
-func (p InstanceProvisioner) Provision(ac bpagclient.Client, job bpdep.Job, depInstance bpdep.Instance) (Instance, error) {
-	p.logger.Debug(instanceProvisionerLogTag, "Updating instance")
-
-	updater := p.instanceUpdaterFactory.NewUpdater(ac, job, depInstance)
-
-	err := updater.SetUp()
-	if err != nil {
-		return Instance{}, bosherr.WrapError(err, "Updating instance %d", depInstance.Index)
-	}
-
-	return NewInstance(updater, job, depInstance, p.logger), nil
-}
-
-func (p InstanceProvisioner) PreviouslyProvisioned(ac bpagclient.Client, job bpdep.Job, depInstance bpdep.Instance) Instance {
-	p.logger.Debug(instanceProvisionerLogTag, "Finding previously provisioned instance")
-
-	updater := p.instanceUpdaterFactory.NewUpdater(ac, job, depInstance)
-
-	return NewInstance(updater, job, depInstance, p.logger)
-}

data/go/src/boshprovisioner/instance/templatescompiler/concrete_templates_compiler.go

@@ -1,284 +0,0 @@
-package templatescompiler
-
-import (
-	"fmt"
-
-	boshblob "bosh/blobstore"
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-
-	bpdep "boshprovisioner/deployment"
-	bpjobsrepo "boshprovisioner/instance/templatescompiler/jobsrepo"
-	bptplsrepo "boshprovisioner/instance/templatescompiler/templatesrepo"
-	bprel "boshprovisioner/release"
-	bpreljob "boshprovisioner/release/job"
-)
-
-type ConcreteTemplatesCompiler struct {
-	renderedArchivesCompiler RenderedArchivesCompiler
-	jobReaderFactory         bpreljob.ReaderFactory
-
-	jobsRepo      bpjobsrepo.JobsRepository
-	tplToJobRepo  bpjobsrepo.TemplateToJobRepository
-	runPkgsRepo   bpjobsrepo.RuntimePackagesRepository
-	templatesRepo bptplsrepo.TemplatesRepository
-
-	blobstore boshblob.Blobstore
-	logger    boshlog.Logger
-}
-
-func NewConcreteTemplatesCompiler(
-	renderedArchivesCompiler RenderedArchivesCompiler,
-	jobReaderFactory bpreljob.ReaderFactory,
-	jobsRepo bpjobsrepo.JobsRepository,
-	tplToJobRepo bpjobsrepo.TemplateToJobRepository,
-	runPkgsRepo bpjobsrepo.RuntimePackagesRepository,
-	templatesRepo bptplsrepo.TemplatesRepository,
-	blobstore boshblob.Blobstore,
-	logger boshlog.Logger,
-) ConcreteTemplatesCompiler {
-	return ConcreteTemplatesCompiler{
-		renderedArchivesCompiler: renderedArchivesCompiler,
-		jobReaderFactory:         jobReaderFactory,
-
-		jobsRepo:      jobsRepo,
-		tplToJobRepo:  tplToJobRepo,
-		runPkgsRepo:   runPkgsRepo,
-		templatesRepo: templatesRepo,
-
-		blobstore: blobstore,
-		logger:    logger,
-	}
-}
-
-// Precompile prepares release jobs to be later combined with instance properties
-func (tc ConcreteTemplatesCompiler) Precompile(release bprel.Release) error {
-	var allPkgs []bprel.Package
-
-	for _, pkg := range release.Packages {
-		if pkg == nil {
-			// todo panic or should not be here?
-			return bosherr.New("Expected release to not have nil package")
-		}
-
-		allPkgs = append(allPkgs, *pkg)
-	}
-
-	for _, job := range release.Jobs {
-		jobRec, found, err := tc.jobsRepo.Find(job)
-		if err != nil {
-			return bosherr.WrapError(err, "Finding job source blob %s", job.Name)
-		}
-
-		if !found {
-			blobID, fingerprint, err := tc.blobstore.Create(job.TarPath)
-			if err != nil {
-				return bosherr.WrapError(err, "Creating job source blob %s", job.Name)
-			}
-
-			jobRec = bpjobsrepo.JobRecord{
-				BlobID: blobID,
-				SHA1:   fingerprint,
-			}
-
-			err = tc.jobsRepo.Save(job, jobRec)
-			if err != nil {
-				return bosherr.WrapError(err, "Saving job record %s", job.Name)
-			}
-		}
-
-		releaseJobRec, err := tc.tplToJobRepo.SaveForJob(release, job)
-		if err != nil {
-			return bosherr.WrapError(err, "Saving release job %s", job.Name)
-		}
-
-		// todo associate to release instead
-		err = tc.runPkgsRepo.SaveAll(releaseJobRec, allPkgs)
-		if err != nil {
-			return bosherr.WrapError(err, "Saving release job %s", job.Name)
-		}
-	}
-
-	return nil
-}
-
-// Compile populates blobstore with rendered jobs for a given deployment instance.
-func (tc ConcreteTemplatesCompiler) Compile(job bpdep.Job, instance bpdep.Instance) error {
-	blobID, fingerprint, err := tc.compileJob(job, instance)
-	if err != nil {
-		return err
-	}
-
-	templateRec := bptplsrepo.TemplateRecord{
-		BlobID: blobID,
-		SHA1:   fingerprint,
-	}
-
-	err = tc.templatesRepo.Save(job, instance, templateRec)
-	if err != nil {
-		return bosherr.WrapError(err, "Saving compiled templates record %s", job.Name)
-	}
-
-	return nil
-}
-
-// FindPackages returns list of packages required to run job template.
-// List of packages is usually specified in release job metadata.
-func (tc ConcreteTemplatesCompiler) FindPackages(template bpdep.Template) ([]bprel.Package, error) {
-	var pkgs []bprel.Package
-
-	releaseJobRec, found, err := tc.tplToJobRepo.FindByTemplate(template)
-	if err != nil {
-		return pkgs, bosherr.WrapError(err, "Finding release job record by template %s", template.Name)
-	} else if !found {
-		return pkgs, bosherr.New("Expected to find release job record by template %s", template.Name)
-	}
-
-	pkgs, found, err = tc.runPkgsRepo.Find(releaseJobRec)
-	if err != nil {
-		return pkgs, bosherr.WrapError(err, "Finding packages by release job record %v", releaseJobRec)
-	} else if !found {
-		return pkgs, bosherr.New("Expected to find packages by release job record %v", releaseJobRec)
-	}
-
-	return pkgs, nil
-}
-
-// FindRenderedArchive returns previously compiled template for a given instance.
-// If such compiled template is not found, error is returned.
-func (tc ConcreteTemplatesCompiler) FindRenderedArchive(job bpdep.Job, instance bpdep.Instance) (RenderedArchiveRecord, error) {
-	var renderedArchiveRec RenderedArchiveRecord
-
-	rec, found, err := tc.templatesRepo.Find(job, instance)
-	if err != nil {
-		return renderedArchiveRec, bosherr.WrapError(err, "Finding compiled templates %s", job.Name)
-	} else if !found {
-		return renderedArchiveRec, bosherr.New("Expected to find compiled templates %s", job.Name)
-	}
-
-	renderedArchiveRec.SHA1 = rec.SHA1
-	renderedArchiveRec.BlobID = rec.BlobID
-
-	return renderedArchiveRec, nil
-}
-
-// compileJob produces and saves rendered templates archive to a blobstore.
-func (tc ConcreteTemplatesCompiler) compileJob(job bpdep.Job, instance bpdep.Instance) (string, string, error) {
-	jobReaders, err := tc.buildJobReaders(job)
-	if err != nil {
-		return "", "", bosherr.WrapError(err, "Building job readers")
-	}
-
-	var relJobs []bpreljob.Job
-
-	for _, jobReader := range jobReaders {
-		relJob, err := jobReader.tarReader.Read()
-		if err != nil {
-			return "", "", bosherr.WrapError(err, "Reading job")
-		}
-
-		defer jobReader.tarReader.Close()
-
-		err = tc.associatePackages(jobReader.rec, relJob)
-		if err != nil {
-			return "", "", bosherr.WrapError(err, "Preparing runtime dep packages")
-		}
-
-		relJobs = append(relJobs, relJob)
-	}
-
-	renderedArchivePath, err := tc.renderedArchivesCompiler.Compile(relJobs, instance)
-	if err != nil {
-		return "", "", bosherr.WrapError(err, "Compiling templates")
-	}
-
-	defer tc.renderedArchivesCompiler.CleanUp(renderedArchivePath)
-
-	blobID, fingerprint, err := tc.blobstore.Create(renderedArchivePath)
-	if err != nil {
-		return "", "", bosherr.WrapError(err, "Creating compiled templates")
-	}
-
-	return blobID, fingerprint, nil
-}
-
-type jobReader struct {
-	rec       bpjobsrepo.ReleaseJobRecord
-	tarReader *bpreljob.TarReader
-}
-
-func (tc ConcreteTemplatesCompiler) buildJobReaders(job bpdep.Job) ([]jobReader, error) {
-	var readers []jobReader
-
-	for _, template := range job.Templates {
-		rec, found, err := tc.tplToJobRepo.FindByTemplate(template)
-		if err != nil {
-			return readers, bosherr.WrapError(err, "Finding dep-template -> release-job record %s", template.Name)
-		} else if !found {
-			return readers, bosherr.New("Expected to find dep-template -> release-job record %s", template.Name)
-		}
-
-		jobRec, found, err := tc.jobsRepo.FindByReleaseJob(rec)
-		if err != nil {
-			return readers, bosherr.WrapError(err, "Finding job source blob %s", template.Name)
-		} else if !found {
-			return readers, bosherr.New("Expected to find job source blob %s -- %s", template.Name, rec)
-		}
-
-		jobURL := fmt.Sprintf("blobstore:///%s?fingerprint=%s", jobRec.BlobID, jobRec.SHA1)
-
-		reader := jobReader{
-			rec:       rec,
-			tarReader: tc.jobReaderFactory.NewTarReader(jobURL),
-		}
-
-		readers = append(readers, reader)
-	}
-
-	return readers, nil
-}
-
-func (tc ConcreteTemplatesCompiler) associatePackages(rec bpjobsrepo.ReleaseJobRecord, relJob bpreljob.Job) error {
-	_, found, err := tc.runPkgsRepo.Find(rec)
-	if err != nil {
-		return bosherr.WrapError(err, "Finding runtime deps for %s", rec)
-	}
-
-	if found {
-		return nil
-	}
-
-	// Find all packages in the same release,
-	// regardless if job previously was associated with packages
-	allPkgs, found, err := tc.runPkgsRepo.FindAll(rec)
-	if err != nil {
-		return bosherr.WrapError(err, "Finding rel-job -> rel-pkgs %s", rec)
-	} else if !found {
-		return bosherr.New("Expected to find rel-job -> rel-pkgs %s", rec)
-	}
-
-	var pkgs []bprel.Package
-
-	// From all packages, select packages that are used by the job
-	for _, pkg := range allPkgs {
-		for _, p := range relJob.Packages {
-			if pkg.Name == p.Name {
-				pkgs = append(pkgs, pkg)
-				break
-			}
-		}
-	}
-
-	// Return error if at least one depedency is missing
-	if len(pkgs) != len(relJob.Packages) {
-		return bosherr.New("Expected to find all release packages")
-	}
-
-	// Associate those packages with a job
-	err = tc.runPkgsRepo.Save(rec, pkgs)
-	if err != nil {
-		return bosherr.WrapError(err, "Saving job packages %s", rec)
-	}
-
-	return nil
-}