vagrant-bosh 0.0.4 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b39c42d2c0ba1faafad24df1d60a9d0f0c5a307
+  data.tar.gz: a0e9d0f83323e94d562920c7b36bed3c50e3b44d
+SHA512:
+  metadata.gz: e41b4554521cc02ef5e25b4adc3a49fd86569abcaf2ebf52e204c0230573c4138a28465e3ad99bcb41c0315637db2a220b0dcab15cfd4fd4c98ff3c84f5020b0
+  data.tar.gz: 896cf5defcceb1c98e6ee9825e07e2946889874884eba1be76b851edbf2359a2b2236a07f7b341bae4bec1ebfdc75d0356c79ca74b7116df80650c87705b1fbd

data/README.md

@@ -66,6 +66,8 @@ end
 
 - `agent_configuration` (Hash, default: '{ ... }')
 
+- `create_release_cmd` (String, default: `bosh -n create release --force`)
+
 
 ### Using BOSH provisioner to build BOSH stemcells
 

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

@@ -87,13 +87,13 @@ func (tc ConcreteTemplatesCompiler) Precompile(release bprel.Release) error {
 			}
 		}
 
-		err = tc.tplToJobRepo.SaveForJob(release, job)
+		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.SaveAllForReleaseJob(job, allPkgs)
+		err = tc.runPkgsRepo.SaveAll(releaseJobRec, allPkgs)
 		if err != nil {
 			return bosherr.WrapError(err, "Saving release job %s", job.Name)
 		}
@@ -104,12 +104,7 @@ func (tc ConcreteTemplatesCompiler) Precompile(release bprel.Release) error {
 
 // Compile populates blobstore with rendered jobs for a given deployment instance.
 func (tc ConcreteTemplatesCompiler) Compile(job bpdep.Job, instance bpdep.Instance) error {
-	relJobReaders, err := tc.buildJobReaders(job)
-	if err != nil {
-		return err
-	}
-
-	blobID, fingerprint, err := tc.compileJob(relJobReaders, instance)
+	blobID, fingerprint, err := tc.compileJob(job, instance)
 	if err != nil {
 		return err
 	}
@@ -132,18 +127,18 @@ func (tc ConcreteTemplatesCompiler) Compile(job bpdep.Job, instance bpdep.Instan
 func (tc ConcreteTemplatesCompiler) FindPackages(template bpdep.Template) ([]bprel.Package, error) {
 	var pkgs []bprel.Package
 
-	job, found, err := tc.tplToJobRepo.FindByTemplate(template)
+	releaseJobRec, found, err := tc.tplToJobRepo.FindByTemplate(template)
 	if err != nil {
-		return pkgs, bosherr.WrapError(err, "Finding job by template %s", template.Name)
+		return pkgs, bosherr.WrapError(err, "Finding release job record by template %s", template.Name)
 	} else if !found {
-		return pkgs, bosherr.New("Expected to find job by template %s", template.Name)
+		return pkgs, bosherr.New("Expected to find release job record by template %s", template.Name)
 	}
 
-	pkgs, found, err = tc.runPkgsRepo.FindByReleaseJob(job)
+	pkgs, found, err = tc.runPkgsRepo.Find(releaseJobRec)
 	if err != nil {
-		return pkgs, bosherr.WrapError(err, "Finding packages by job %s", job.Name)
+		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 job %s", job.Name)
+		return pkgs, bosherr.New("Expected to find packages by release job record %v", releaseJobRec)
 	}
 
 	return pkgs, nil
@@ -167,44 +162,13 @@ func (tc ConcreteTemplatesCompiler) FindRenderedArchive(job bpdep.Job, instance
 	return renderedArchiveRec, nil
 }
 
-type jobReader struct {
-	relJob    bprel.Job
-	tarReader *bpreljob.TarReader
-}
-
-func (tc ConcreteTemplatesCompiler) buildJobReaders(job bpdep.Job) ([]jobReader, error) {
-	var readers []jobReader
-
-	for _, template := range job.Templates {
-		relJob, found, err := tc.tplToJobRepo.FindByTemplate(template)
-		if err != nil {
-			return readers, bosherr.WrapError(err, "Finding dep-template -> rel-job %s", template.Name)
-		} else if !found {
-			return readers, bosherr.New("Expected to find dep-template -> rel-job %s", template.Name)
-		}
-
-		jobRec, found, err := tc.jobsRepo.Find(relJob)
-		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", template.Name)
-		}
-
-		jobURL := fmt.Sprintf("blobstore:///%s?fingerprint=%s", jobRec.BlobID, jobRec.SHA1)
-
-		reader := jobReader{
-			relJob:    relJob,
-			tarReader: tc.jobReaderFactory.NewTarReader(jobURL),
-		}
-
-		readers = append(readers, reader)
+// 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")
 	}
 
-	return readers, nil
-}
-
-// compileJob produces and saves rendered templates archive to a blobstore.
-func (tc ConcreteTemplatesCompiler) compileJob(jobReaders []jobReader, instance bpdep.Instance) (string, string, error) {
 	var relJobs []bpreljob.Job
 
 	for _, jobReader := range jobReaders {
@@ -215,7 +179,7 @@ func (tc ConcreteTemplatesCompiler) compileJob(jobReaders []jobReader, instance
 
 		defer jobReader.tarReader.Close()
 
-		err = tc.associatePackages(jobReader.relJob, relJob)
+		err = tc.associatePackages(jobReader.rec, relJob)
 		if err != nil {
 			return "", "", bosherr.WrapError(err, "Preparing runtime dep packages")
 		}
@@ -238,36 +202,83 @@ func (tc ConcreteTemplatesCompiler) compileJob(jobReaders []jobReader, instance
 	return blobID, fingerprint, nil
 }
 
-func (tc ConcreteTemplatesCompiler) associatePackages(rJob bprel.Job, relJob bpreljob.Job) error {
-	_, found, err := tc.runPkgsRepo.FindByReleaseJob(rJob)
-	if err != nil {
-		return bosherr.WrapError(err, "Finding runtime deps for %s", rJob.Name)
-	}
+type jobReader struct {
+	rec       bpjobsrepo.ReleaseJobRecord
+	tarReader *bpreljob.TarReader
+}
 
-	if !found {
-		allPkgs, found, err := tc.runPkgsRepo.FindAllByReleaseJob(rJob)
+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 bosherr.WrapError(err, "Finding rel-job -> rel-pkgs %s", rJob.Name)
+			return readers, bosherr.WrapError(err, "Finding dep-template -> release-job record %s", template.Name)
 		} else if !found {
-			return bosherr.New("Expected to find rel-job -> rel-pkgs %s", rJob.Name)
+			return readers, bosherr.New("Expected to find dep-template -> release-job record %s", template.Name)
 		}
 
-		var pkgs []bprel.Package
+		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)
+		}
 
-		for _, pkg := range allPkgs {
-			for _, p := range relJob.Packages {
-				if pkg.Name == p.Name {
-					pkgs = append(pkgs, pkg)
-					break
-				}
-			}
+		jobURL := fmt.Sprintf("blobstore:///%s?fingerprint=%s", jobRec.BlobID, jobRec.SHA1)
+
+		reader := jobReader{
+			rec:       rec,
+			tarReader: tc.jobReaderFactory.NewTarReader(jobURL),
 		}
 
-		err = tc.runPkgsRepo.SaveForReleaseJob(rJob, pkgs)
-		if err != nil {
-			return bosherr.WrapError(err, "Saving job packages %s", rJob.Name)
+		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
 }

data/go/src/boshprovisioner/instance/templatescompiler/jobsrepo/concrete_jobs_repository.go

@@ -17,7 +17,8 @@ type jobToJobKey struct {
 	JobName    string
 	JobVersion string
 
-	// Fingerprint of a package captures its dependenices
+	// Fingerprint of a job captures its dependenices; however,
+	// that does not capture package changes in an associated release.
 	JobFingerprint string
 }
 
@@ -34,28 +35,49 @@ func NewConcreteJobsRepository(
 func (r CJRepository) Find(job bprel.Job) (JobRecord, bool, error) {
 	var record JobRecord
 
-	err := r.index.Find(r.jobKey(job), &record)
+	err := r.index.Find(r.key(job), &record)
 	if err != nil {
 		if err == bpindex.ErrNotFound {
 			return record, false, nil
 		}
 
-		return record, false, bosherr.WrapError(err, "Finding package record")
+		return record, false, bosherr.WrapError(err, "Finding job record")
+	}
+
+	return record, true, nil
+}
+
+func (r CJRepository) FindByReleaseJob(rec ReleaseJobRecord) (JobRecord, bool, error) {
+	var record JobRecord
+
+	key := jobToJobKey{
+		JobName:        rec.JobName,
+		JobVersion:     rec.JobVersion,
+		JobFingerprint: rec.JobFingerprint,
+	}
+
+	err := r.index.Find(key, &record)
+	if err != nil {
+		if err == bpindex.ErrNotFound {
+			return record, false, nil
+		}
+
+		return record, false, bosherr.WrapError(err, "Finding job record")
 	}
 
 	return record, true, nil
 }
 
 func (r CJRepository) Save(job bprel.Job, record JobRecord) error {
-	err := r.index.Save(r.jobKey(job), record)
+	err := r.index.Save(r.key(job), record)
 	if err != nil {
-		return bosherr.WrapError(err, "Saving package record")
+		return bosherr.WrapError(err, "Saving job record")
 	}
 
 	return nil
 }
 
-func (r CJRepository) jobKey(job bprel.Job) jobToJobKey {
+func (r CJRepository) key(job bprel.Job) jobToJobKey {
 	return jobToJobKey{
 		JobName:        job.Name,
 		JobVersion:     job.Version,

data/go/src/boshprovisioner/instance/templatescompiler/jobsrepo/concrete_runtime_packages_repository.go

@@ -24,6 +24,9 @@ func NewConcreteRuntimePackagesRepository(
 }
 
 type jobToPkgsKey struct {
+	ReleaseName    string
+	ReleaseVersion string
+
 	// Mostly for ease of debugging
 	JobName    string
 	JobVersion string
@@ -35,70 +38,75 @@ type jobToPkgsKey struct {
 	ContainsAllPackages bool
 }
 
-func (r CRPRepository) FindByReleaseJob(job bprel.Job) ([]bprel.Package, bool, error) {
+func (r CRPRepository) Find(rec ReleaseJobRecord) ([]bprel.Package, bool, error) {
 	var pkgs []bprel.Package
 
-	err := r.index.Find(r.jobSpecificKey(job), &pkgs)
+	err := r.index.Find(r.jobSpecificKey(rec), &pkgs)
 	if err != nil {
 		if err == bpindex.ErrNotFound {
 			return pkgs, false, nil
 		}
 
-		return pkgs, false, bosherr.WrapError(err, "Finding rel-job -> specific rel-pkgs record")
+		return pkgs, false, bosherr.WrapError(err, "Finding rel-job record -> specific rel-pkgs record")
 	}
 
 	return pkgs, true, nil
 }
 
-func (r CRPRepository) SaveForReleaseJob(job bprel.Job, pkgs []bprel.Package) error {
-	err := r.index.Save(r.jobSpecificKey(job), pkgs)
+func (r CRPRepository) Save(rec ReleaseJobRecord, pkgs []bprel.Package) error {
+	err := r.index.Save(r.jobSpecificKey(rec), pkgs)
 	if err != nil {
-		return bosherr.WrapError(err, "Saving rel-job -> specific rel-pkgs record")
+		return bosherr.WrapError(err, "Saving rel-job record -> specific rel-pkgs record")
 	}
 
 	return nil
 }
 
-// FindAllByReleaseJob keeps association between all possible packages for a job
-func (r CRPRepository) FindAllByReleaseJob(job bprel.Job) ([]bprel.Package, bool, error) {
+func (r CRPRepository) FindAll(rec ReleaseJobRecord) ([]bprel.Package, bool, error) {
 	var pkgs []bprel.Package
 
-	err := r.index.Find(r.jobAllKey(job), &pkgs)
+	err := r.index.Find(r.jobAllKey(rec), &pkgs)
 	if err != nil {
 		if err == bpindex.ErrNotFound {
 			return pkgs, false, nil
 		}
 
-		return pkgs, false, bosherr.WrapError(err, "Finding rel-job -> all rel-pkgs record")
+		return pkgs, false, bosherr.WrapError(err, "Finding rel-job record -> all rel-pkgs record")
 	}
 
 	return pkgs, true, nil
 }
 
-func (r CRPRepository) SaveAllForReleaseJob(job bprel.Job, pkgs []bprel.Package) error {
-	err := r.index.Save(r.jobAllKey(job), pkgs)
+func (r CRPRepository) SaveAll(rec ReleaseJobRecord, pkgs []bprel.Package) error {
+	err := r.index.Save(r.jobAllKey(rec), pkgs)
 	if err != nil {
-		return bosherr.WrapError(err, "Saving rel-job -> all rel-pkgs record")
+		return bosherr.WrapError(err, "Saving rel-job record -> all rel-pkgs record")
 	}
 
 	return nil
 }
 
-func (r CRPRepository) jobSpecificKey(job bprel.Job) jobToPkgsKey {
+func (r CRPRepository) jobSpecificKey(rec ReleaseJobRecord) jobToPkgsKey {
 	return jobToPkgsKey{
-		JobName:        job.Name,
-		JobVersion:     job.Version,
-		JobFingerprint: job.Fingerprint,
+		ReleaseName:    rec.ReleaseName,
+		ReleaseVersion: rec.ReleaseVersion,
+
+		JobName:        rec.JobName,
+		JobVersion:     rec.JobVersion,
+		JobFingerprint: rec.JobFingerprint,
 
 		ContainsAllPackages: false,
 	}
 }
 
-func (r CRPRepository) jobAllKey(job bprel.Job) jobToPkgsKey {
+func (r CRPRepository) jobAllKey(rec ReleaseJobRecord) jobToPkgsKey {
 	return jobToPkgsKey{
-		JobName:        job.Name,
-		JobVersion:     job.Version,
-		JobFingerprint: job.Fingerprint,
+		ReleaseName:    rec.ReleaseName,
+		ReleaseVersion: rec.ReleaseVersion,
+
+		JobName:        rec.JobName,
+		JobVersion:     rec.JobVersion,
+		JobFingerprint: rec.JobFingerprint,
 
 		ContainsAllPackages: true,
 	}

data/go/src/boshprovisioner/instance/templatescompiler/jobsrepo/concrete_template_to_job_repository.go

@@ -30,28 +30,38 @@ func NewConcreteTemplateToJobRepository(
 	}
 }
 
-func (r CTTJRepository) FindByTemplate(template bpdep.Template) (bprel.Job, bool, error) {
-	var job bprel.Job
+func (r CTTJRepository) FindByTemplate(template bpdep.Template) (ReleaseJobRecord, bool, error) {
+	var rec ReleaseJobRecord
 
-	err := r.index.Find(r.templateKey(template), &job)
+	err := r.index.Find(r.templateKey(template), &rec)
 	if err != nil {
 		if err == bpindex.ErrNotFound {
-			return job, false, nil
+			return rec, false, nil
 		}
 
-		return job, false, bosherr.WrapError(err, "Finding dep-template -> rel-job record")
+		return rec, false, bosherr.WrapError(err, "Finding dep-template -> release-job record")
 	}
 
-	return job, true, nil
+	return rec, true, nil
 }
 
-func (r CTTJRepository) SaveForJob(release bprel.Release, job bprel.Job) error {
-	err := r.index.Save(r.jobKey(release, job), job)
+func (r CTTJRepository) SaveForJob(release bprel.Release, job bprel.Job) (ReleaseJobRecord, error) {
+	// todo redundant info stored in value
+	rec := ReleaseJobRecord{
+		ReleaseName:    release.Name,
+		ReleaseVersion: release.Version,
+
+		JobName:        job.Name,
+		JobVersion:     job.Version,
+		JobFingerprint: job.Fingerprint,
+	}
+
+	err := r.index.Save(r.jobKey(release, job), rec)
 	if err != nil {
-		return bosherr.WrapError(err, "Saving dep-template -> rel-job record")
+		return rec, bosherr.WrapError(err, "Saving dep-template -> release-job record")
 	}
 
-	return nil
+	return rec, nil
 }
 
 func (r CTTJRepository) templateKey(template bpdep.Template) templateToJobKey {

data/go/src/boshprovisioner/instance/templatescompiler/jobsrepo/jobs_repository_interface.go

@@ -1,6 +1,8 @@
 package jobsrepo
 
 import (
+	"fmt"
+
 	bpdep "boshprovisioner/deployment"
 	bprel "boshprovisioner/release"
 )
@@ -10,22 +12,38 @@ type JobRecord struct {
 	SHA1   string
 }
 
+type ReleaseJobRecord struct {
+	ReleaseName    string
+	ReleaseVersion string
+
+	JobName        string
+	JobVersion     string
+	JobFingerprint string
+}
+
+func (r ReleaseJobRecord) String() string {
+	return fmt.Sprintf("job %s in release %s/%s", r.JobName, r.ReleaseName, r.ReleaseVersion)
+}
+
 // JobsRepository maintains list of job source code as blobs
 type JobsRepository interface {
 	Find(bprel.Job) (JobRecord, bool, error)
 	Save(bprel.Job, JobRecord) error
+
+	FindByReleaseJob(ReleaseJobRecord) (JobRecord, bool, error)
 }
 
 type TemplateToJobRepository interface {
-	FindByTemplate(bpdep.Template) (bprel.Job, bool, error)
-	SaveForJob(bprel.Release, bprel.Job) error
+	FindByTemplate(bpdep.Template) (ReleaseJobRecord, bool, error)
+	SaveForJob(bprel.Release, bprel.Job) (ReleaseJobRecord, error)
 }
 
+// RuntimePackagesRepository maintains list of releases' packages
 type RuntimePackagesRepository interface {
-	FindByReleaseJob(bprel.Job) ([]bprel.Package, bool, error)
-	SaveForReleaseJob(bprel.Job, []bprel.Package) error
+	Find(ReleaseJobRecord) ([]bprel.Package, bool, error)
+	Save(ReleaseJobRecord, []bprel.Package) error
 
 	// Keeps association between all possible packages for a job
-	FindAllByReleaseJob(bprel.Job) ([]bprel.Package, bool, error)
-	SaveAllForReleaseJob(bprel.Job, []bprel.Package) error
+	FindAll(ReleaseJobRecord) ([]bprel.Package, bool, error)
+	SaveAll(ReleaseJobRecord, []bprel.Package) error
 }

data/go/src/boshprovisioner/release/dir_reader.go

@@ -73,18 +73,37 @@ func (r DirReader) Close() error {
 
 // populateReleaseTarPaths sets TarPath for each job/package in the release.
 func (r DirReader) populateReleaseTarPaths(release *Release) {
+	devBuilds := filepath.Join(r.dir, ".dev_builds")
+	finalBuilds := filepath.Join(r.dir, ".final_builds")
+
 	for i, job := range release.Jobs {
 		fileName := job.Fingerprint + ".tgz"
 
-		release.Jobs[i].TarPath = filepath.Join(
-			r.dir, ".dev_builds", "jobs", job.Name, fileName)
+		devPath := filepath.Join(devBuilds, "jobs", job.Name, fileName)
+		finalPath := filepath.Join(finalBuilds, "jobs", job.Name, fileName)
+
+		release.Jobs[i].TarPath = r.pathThatExistsOrEmpty(devPath, finalPath)
 	}
 
 	for _, pkg := range release.Packages {
 		fileName := pkg.Fingerprint + ".tgz"
 
-		pkg.TarPath = filepath.Join(
-			r.dir, ".dev_builds", "packages", pkg.Name, fileName)
+		devPath := filepath.Join(devBuilds, "packages", pkg.Name, fileName)
+		finalPath := filepath.Join(finalBuilds, "packages", pkg.Name, fileName)
+
+		pkg.TarPath = r.pathThatExistsOrEmpty(devPath, finalPath)
+	}
+}
+
+// pathThatExists returns first path that exists on the file system.
+func (r DirReader) pathThatExistsOrEmpty(firstPath, secondPath string) string {
+	switch {
+	case r.fs.FileExists(firstPath):
+		return firstPath
+	case r.fs.FileExists(secondPath):
+		return secondPath
+	default:
+		return ""
 	}
 }
 

data/go/src/boshprovisioner/vm/vagrant/agent_provisioner.go

@@ -99,15 +99,15 @@ func (p AgentProvisioner) Provision() error {
 func (p AgentProvisioner) Configure(instance bpdep.Instance) (bpagclient.Client, error) {
 	stage := p.eventLog.BeginStage("Configuring BOSH agent", 1)
 
-	task := stage.BeginTask("Configuring infrastructure settings")
-
-	err := task.End(p.placeInfSettings(instance))
+	err := p.placeInfSettings(instance)
 	if err != nil {
 		return nil, bosherr.WrapError(err, "Placing infrastructure settings")
 	}
 
+	task := stage.BeginTask("Configuring infrastructure settings")
+
 	agentClient, err := p.buildAgentClient()
-	if err != nil {
+	if task.End(err) != nil {
 		return nil, bosherr.WrapError(err, "Building agent client")
 	}
 

data/lib/vagrant-bosh/config.rb

@@ -20,6 +20,11 @@ module VagrantPlugins
 
       attr_accessor :agent_infrastructure, :agent_platform, :agent_configuration
 
+      # Command to run to create a BOSH release on the host.
+      # BOSH release has a rake task to create a dev release 
+      # because it creates locally versioned gems.
+      attr_accessor :create_release_cmd
+
       def initialize(*args)
         super
         @base_dir = "/opt/vagrant-bosh"
@@ -36,6 +41,8 @@ module VagrantPlugins
         @synced_releases_dir = File.join(@base_dir, "synced-releases")
 
         @full_stemcell_compatibility = !!@full_stemcell_compatibility
+
+        @create_release_cmd ||= "bosh -n create release --force"
       end
 
       def validate(machine)

data/lib/vagrant-bosh/deployment/release_uploader.rb

@@ -16,21 +16,23 @@ module VagrantPlugins
         def sync(host_dir, guest_dir)
           # RsyncHelper uses @machine.ui internally
 
-          # .dev_builds/ contains jobs/ and packages/ tgzs
-          SyncedFolderRSync::RsyncHelper.rsync_single(@machine, @machine.ssh_info, {
-            type:      :rsync, 
-            hostpath:  File.join(host_dir, ".dev_builds"),
-            guestpath: File.join(guest_dir, ".dev_builds"),
-            disabled:  false,
-          })
-
-          # dev_releases/ contains dev release manifest files
-          SyncedFolderRSync::RsyncHelper.rsync_single(@machine, @machine.ssh_info, {
-            type:      :rsync, 
-            hostpath:  File.join(host_dir, "dev_releases"),
-            guestpath: File.join(guest_dir, "dev_releases"),
-            disabled:  false,
-          })
+          dir_names = [
+            # .dev_builds/ and .final_builds/ contain jobs/ and packages/ tgzs
+            ".dev_builds",
+            ".final_builds",
+
+            # dev_releases/ contains dev release manifest files
+            "dev_releases",            
+          ]
+
+          dir_names.each do |dir_name|
+            SyncedFolderRSync::RsyncHelper.rsync_single(@machine, @machine.ssh_info, {
+              type:      :rsync, 
+              hostpath:  File.join(host_dir, dir_name),
+              guestpath: File.join(guest_dir, dir_name),
+              disabled:  false,
+            })
+          end
         end
       end
 

data/lib/vagrant-bosh/deployment/uploadable_release.rb

@@ -10,11 +10,12 @@ module VagrantPlugins
       # UplodableRelease represents a release 
       # that *can be* synced to a guest FS location.
       class UplodableRelease
-        def initialize(name, version, host_dir, guest_root_dir, release_uploader, ui)
+        def initialize(name, version, host_dir, guest_root_dir, release_uploader, create_release_cmd, ui)
           @name = name
           @version = version
           @host_dir = host_dir
           @release_uploader = release_uploader
+          @create_release_cmd = create_release_cmd
 
           @ui = ui.for(:deployment, :uploadable_release)
           @logger = Log4r::Logger.new("vagrant::provisioners::bosh::deployment::uploadable_release")
@@ -35,11 +36,13 @@ module VagrantPlugins
 
         def create_release
           result = @ui.timed_msg(:create_release, name: @name) do
+            shell = ENV["SHELL"] || "bash"
+
             # Without clearing out environment Vagrant ruby env will be inherited
             Vagrant::Util::Subprocess.execute(
-              "env",  "-i", "HOME=#{ENV["HOME"]}", "TERM=#{ENV["TERM"]}", 
-              "bash", "-l", "-c", 
-              "bosh create release --force", 
+              "env", "-i", "HOME=#{ENV["HOME"]}", "TERM=#{ENV["TERM"]}",
+              shell, "-l", "-c", 
+              @create_release_cmd,
               {workdir: @host_dir},
             )
           end

data/lib/vagrant-bosh/deployment/uploadable_release_factory.rb

@@ -4,9 +4,10 @@ module VagrantPlugins
   module VagrantBosh
     module Deployment
       class UploadableReleaseFactory
-        def initialize(guest_root_dir, release_uploader, ui)
+        def initialize(guest_root_dir, release_uploader, create_release_cmd, ui)
           @guest_root_dir = guest_root_dir
           @release_uploader = release_uploader
+          @create_release_cmd = create_release_cmd
           @ui = ui
         end
 
@@ -17,6 +18,7 @@ module VagrantPlugins
             host_dir, 
             @guest_root_dir, 
             @release_uploader, 
+            @create_release_cmd,
             @ui,
           )
         end

data/lib/vagrant-bosh/provisioner.rb

@@ -34,6 +34,7 @@ module VagrantPlugins
         uploadable_release_factory = Deployment::UploadableReleaseFactory.new(
           config.synced_releases_dir,
           release_uploader,
+          config.create_release_cmd,
           machine_ui,
         )
 

data/lib/vagrant-bosh/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module VagrantBosh
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-bosh
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.0.5
 platform: ruby
 authors:
 - Dmitriy Kalinin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-30 00:00:00.000000000 Z
+date: 2014-07-15 00:00:00.000000000 Z
 dependencies: []
 description: BOSH provisioner allows to provision guest VM by specifying regular BOSH
   deployment manifest.
@@ -183,27 +182,26 @@ files:
 homepage: https://github.com/cppforlife/vagrant-bosh
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 - templates
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.3.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Vagrant BOSH provisioner plugin.
 test_files: []