vagrant-bosh 0.0.3 → 0.0.4

data/go/src/boshprovisioner/provisioner/single_non_configured_vm_provisioner.go

@@ -0,0 +1,40 @@
+package provisioner
+
+import (
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+
+	bpeventlog "boshprovisioner/eventlog"
+	bpvm "boshprovisioner/vm"
+)
+
+// SingleNonConfiguredVMProvisioner configures 1 VM as a regular empty BOSH VM.
+type SingleNonConfiguredVMProvisioner struct {
+	vmProvisioner bpvm.VMProvisioner
+	eventLog      bpeventlog.Log
+	logger        boshlog.Logger
+}
+
+func NewSingleNonConfiguredVMProvisioner(
+	vmProvisioner bpvm.VMProvisioner,
+	eventLog bpeventlog.Log,
+	logger boshlog.Logger,
+) SingleNonConfiguredVMProvisioner {
+	return SingleNonConfiguredVMProvisioner{
+		vmProvisioner: vmProvisioner,
+		eventLog:      eventLog,
+		logger:        logger,
+	}
+}
+
+func (p SingleNonConfiguredVMProvisioner) Provision() error {
+	// todo VM was possibly provisioned last time
+	_, err := p.vmProvisioner.ProvisionNonConfigured()
+	if err != nil {
+		return bosherr.WrapError(err, "Provisioning VM")
+	}
+
+	// Do not Deprovision() VM to keep instance running
+
+	return nil
+}

data/go/src/boshprovisioner/provisioner/single_vm_provisioner_factory.go

@@ -0,0 +1,68 @@
+package provisioner
+
+import (
+	boshlog "bosh/logger"
+
+	bpdep "boshprovisioner/deployment"
+	bpeventlog "boshprovisioner/eventlog"
+	bpinstance "boshprovisioner/instance"
+	bpvm "boshprovisioner/vm"
+)
+
+type SingleVMProvisionerFactory struct {
+	deploymentReaderFactory     bpdep.ReaderFactory
+	deploymentProvisionerConfig DeploymentProvisionerConfig
+
+	vmProvisioner       bpvm.VMProvisioner
+	releaseCompiler     ReleaseCompiler
+	instanceProvisioner bpinstance.InstanceProvisioner
+
+	eventLog bpeventlog.Log
+	logger   boshlog.Logger
+}
+
+func NewSingleVMProvisionerFactory(
+	deploymentReaderFactory bpdep.ReaderFactory,
+	deploymentProvisionerConfig DeploymentProvisionerConfig,
+	vmProvisioner bpvm.VMProvisioner,
+	releaseCompiler ReleaseCompiler,
+	instanceProvisioner bpinstance.InstanceProvisioner,
+	eventLog bpeventlog.Log,
+	logger boshlog.Logger,
+) SingleVMProvisionerFactory {
+	return SingleVMProvisionerFactory{
+		deploymentReaderFactory:     deploymentReaderFactory,
+		deploymentProvisionerConfig: deploymentProvisionerConfig,
+
+		vmProvisioner:       vmProvisioner,
+		releaseCompiler:     releaseCompiler,
+		instanceProvisioner: instanceProvisioner,
+
+		eventLog: eventLog,
+		logger:   logger,
+	}
+}
+
+func (f SingleVMProvisionerFactory) NewSingleVMProvisioner() DeploymentProvisioner {
+	var prov DeploymentProvisioner
+
+	if len(f.deploymentProvisionerConfig.ManifestPath) > 0 {
+		prov = NewSingleConfiguredVMProvisioner(
+			f.deploymentProvisionerConfig.ManifestPath,
+			f.deploymentReaderFactory,
+			f.vmProvisioner,
+			f.releaseCompiler,
+			f.instanceProvisioner,
+			f.eventLog,
+			f.logger,
+		)
+	} else {
+		prov = NewSingleNonConfiguredVMProvisioner(
+			f.vmProvisioner,
+			f.eventLog,
+			f.logger,
+		)
+	}
+
+	return prov
+}

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

@@ -0,0 +1,127 @@
+package release
+
+import (
+	"path/filepath"
+
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+
+	bprelman "boshprovisioner/release/manifest"
+)
+
+const dirReaderLogTag = "DirReader"
+
+type DirReader struct {
+	releaseName    string // e.g. room101
+	releaseVersion string // e.g. 0+dev.16
+	dir            string
+
+	fs     boshsys.FileSystem
+	logger boshlog.Logger
+}
+
+func NewDirReader(
+	releaseName string,
+	releaseVersion string,
+	dir string,
+	fs boshsys.FileSystem,
+	logger boshlog.Logger,
+) DirReader {
+	return DirReader{
+		releaseName:    releaseName,
+		releaseVersion: releaseVersion,
+		dir:            dir,
+
+		fs:     fs,
+		logger: logger,
+	}
+}
+
+func (r DirReader) Read() (Release, error) {
+	var release Release
+
+	// e.g. room101-0+dev.16.yml
+	manifestFileName := r.releaseName + "-" + r.releaseVersion + ".yml"
+
+	manifestPath := filepath.Join(r.dir, "dev_releases", manifestFileName)
+
+	manifest, err := bprelman.NewManifestFromPath(manifestPath, r.fs)
+	if err != nil {
+		closeErr := r.Close()
+		if closeErr != nil {
+			r.logger.Debug(dirReaderLogTag,
+				"Failed to close release %v", closeErr)
+		}
+
+		return release, bosherr.WrapError(err, "Building manifest")
+	}
+
+	r.logger.Debug(dirReaderLogTag, "Done building manifest %#v", manifest)
+
+	release.populateFromManifest(manifest)
+
+	r.populateReleaseTarPaths(&release)
+
+	return release, nil
+}
+
+func (r DirReader) Close() error {
+	// Caller owns release directory; hence, nothing to clean up
+	return nil
+}
+
+// populateReleaseTarPaths sets TarPath for each job/package in the release.
+func (r DirReader) populateReleaseTarPaths(release *Release) {
+	for i, job := range release.Jobs {
+		fileName := job.Fingerprint + ".tgz"
+
+		release.Jobs[i].TarPath = filepath.Join(
+			r.dir, ".dev_builds", "jobs", job.Name, fileName)
+	}
+
+	for _, pkg := range release.Packages {
+		fileName := pkg.Fingerprint + ".tgz"
+
+		pkg.TarPath = filepath.Join(
+			r.dir, ".dev_builds", "packages", pkg.Name, fileName)
+	}
+}
+
+/*
+Example of BOSH release director with created dev releases:
+
+$ tree ~/Downloads/room101-release
+~/Downloads/room101-release
+├── .dev_builds/
+│ 	├── jobs
+│ 	│   ├── warden
+│ 	│   │   ├── 2a2b0559a97f869274602ffed008827cd66d15c3.tgz
+│ 	│   │   └── index.yml
+│ 	│   └── winston
+│ 	│       ├── 98facd269cd8096a9b0ad354cbb5f0fc4265006f.tgz
+│ 	│       └── index.yml
+│ 	└── packages
+│ 	    ├── aufs
+│ 	    │   ├── cc5b6bf395c60d2aba6e0bc1ceeb613e7aadb52b.tgz
+│ 	    │   └── index.yml
+│ 	    ├── golang_1.2
+│ 	    │   ├── ac825cab297fba938bec25c83f4a5780f88cdc92.tgz
+│ 	    │   └── index.yml
+│ 	    ├── iptables
+│ 	    │   ├── 7226d311e90f49b05287e79f339581a1de9ea82e.tgz
+│ 	    │   └── index.yml
+│ 	    ├── pid_utils
+│ 	    │   ├── de523512921338bac845ea7230e30b4307f842e7.tgz
+│ 	    │   └── index.yml
+│ 	    ├── warden-linux
+│ 	    │   ├── 3f90138dae6c92c3e4595742ab6a513560e32a4c.tgz
+│ 	    │   └── index.yml
+│ 	    └── winston
+│ 	        ├── 69fcbe3ef485a7f9d7c8efa6f18a74a0cffcb213.tgz
+│ 	        └── index.yml
+└── dev_releases
+    ├── index.yml
+    ├── room101-0+dev.1.yml
+    └── room101-0+dev.2.yml
+*/

data/go/src/boshprovisioner/release/manifest/manifest.go

@@ -23,21 +23,31 @@ type Release struct {
 }
 
 type Job struct {
-	Name    string `yaml:"name"`
-	Version string `yaml:"version"`
+	Name string `yaml:"name"`
 
-	Fingerprint string `yaml:"fingerprint"`
-	SHA1        string `yaml:"sha1"`
+	// bosh_cli uses fingerprint as job version
+	VersionRaw string `yaml:"version"`
+	Version    string
 
-	DependencyNames []DependencyName `yaml:"dependencies"`
+	FingerprintRaw string `yaml:"fingerprint"`
+	Fingerprint    string
+
+	SHA1Raw string `yaml:"sha1"`
+	SHA1    string
 }
 
 type Package struct {
-	Name    string `yaml:"name"`
-	Version string `yaml:"version"`
+	Name string `yaml:"name"`
+
+	// bosh_cli uses fingerprint as package version
+	VersionRaw string `yaml:"version"`
+	Version    string
 
-	Fingerprint string `yaml:"fingerprint"`
-	SHA1        string `yaml:"sha1"`
+	FingerprintRaw string `yaml:"fingerprint"`
+	Fingerprint    string
+
+	SHA1Raw string `yaml:"sha1"`
+	SHA1    string
 
 	DependencyNames []DependencyName `yaml:"dependencies"`
 }
@@ -48,20 +58,34 @@ func (p Package) DependencyName() DependencyName {
 
 type DependencyName string
 
+// NewManifestFromPath returns manifest read from the file system.
 func NewManifestFromPath(path string, fs boshsys.FileSystem) (Manifest, error) {
 	bytes, err := fs.ReadFile(path)
 	if err != nil {
 		return Manifest{}, bosherr.WrapError(err, "Reading manifest %s", path)
 	}
 
+	return NewManifestFromBytes(bytes)
+}
+
+// NewManifestFromBytes returns manifest built from given bytes.
+func NewManifestFromBytes(bytes []byte) (Manifest, error) {
+	var manifest Manifest
 	var release Release
 
-	err = candiedyaml.Unmarshal(bytes, &release)
+	err := candiedyaml.Unmarshal(bytes, &release)
+	if err != nil {
+		return manifest, bosherr.WrapError(err, "Parsing release")
+	}
+
+	manifest.Release = release
+
+	err = NewSyntaxValidator(&manifest).Validate()
 	if err != nil {
-		return Manifest{}, bosherr.WrapError(err, "Parsing release")
+		return manifest, bosherr.WrapError(err, "Validating manifest syntactically")
 	}
 
-	return Manifest{Release: release}, nil
+	return manifest, nil
 }
 
 /*
@@ -76,10 +100,10 @@ packages:
 - name: registry
   version: !binary |-
     ZGQxYmEzMzBiYzQ0YjMxODFiMjYzMzgzYjhlNDI1MmQ3MDUxZGVjYQ==
-  sha1: !binary |-
-    NmVhYTZjOTYxZWFjN2JkOTk0ZDE2NDRhZDQwNWIzMzk1NDIwZWNhZg==
   fingerprint: !binary |-
     ZGQxYmEzMzBiYzQ0YjMxODFiMjYzMzgzYjhlNDI1MmQ3MDUxZGVjYQ==
+  sha1: !binary |-
+    NmVhYTZjOTYxZWFjN2JkOTk0ZDE2NDRhZDQwNWIzMzk1NDIwZWNhZg==
   dependencies:
   - libpq
   - mysql

data/go/src/boshprovisioner/release/manifest/manifest_suite_test.go

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

data/go/src/boshprovisioner/release/manifest/manifest_test.go

@@ -0,0 +1,72 @@
+package manifest_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	. "boshprovisioner/release/manifest"
+)
+
+var _ = Describe("Manifest", func() {
+	Describe("NewManifestFromBytes", func() {
+		It("returns manifest with decoded version/fingerprint/sha1 for jobs and packages", func() {
+			manifestBytes := []byte(`
+name: bosh
+version: 77
+
+commit_hash: bbe5476c
+uncommitted_changes: true
+
+packages:
+- name: registry
+  version: !binary |-
+    ZGQxYmEzMzBiYzQ0YjMxODFiMjYzMzgzYjhlNDI1MmQ3MDUxZGVjYQ==
+  fingerprint: !binary |-
+    ZGQxYmEzMzBiYzQ0YjMxODFiMjYzMzgzYjhlNDI1MmQ3MDUxZGVjYQ==
+  sha1: !binary |-
+    NmVhYTZjOTYxZWFjN2JkOTk0ZDE2NDRhZDQwNWIzMzk1NDIwZWNhZg==
+  dependencies: []
+
+jobs:
+- name: powerdns
+  version: !binary |-
+    MGI4MGIzYzE5OGJmN2FiYzZjODEyNjIwMTNkZTQ5NDM2OWZkMjViNg==
+  fingerprint: !binary |-
+    MGI4MGIzYzE5OGJmN2FiYzZjODEyNjIwMTNkZTQ5NDM2OWZkMjViNg==
+  sha1: !binary |-
+    YWI5NzA5YmVhYjViZTBmYjYyYTJkMWYzYzg4ZDA2YzliNGJkZWM2NQ==
+`)
+
+			manifest, err := NewManifestFromBytes(manifestBytes)
+			Expect(err).ToNot(HaveOccurred())
+
+			Expect(manifest.Release.Packages[0]).To(Equal(Package{
+				Name: "registry",
+
+				VersionRaw: "ZGQxYmEzMzBiYzQ0YjMxODFiMjYzMzgzYjhlNDI1MmQ3MDUxZGVjYQ==",
+				Version:    "dd1ba330bc44b3181b263383b8e4252d7051deca",
+
+				FingerprintRaw: "ZGQxYmEzMzBiYzQ0YjMxODFiMjYzMzgzYjhlNDI1MmQ3MDUxZGVjYQ==",
+				Fingerprint:    "dd1ba330bc44b3181b263383b8e4252d7051deca",
+
+				SHA1Raw: "NmVhYTZjOTYxZWFjN2JkOTk0ZDE2NDRhZDQwNWIzMzk1NDIwZWNhZg==",
+				SHA1:    "6eaa6c961eac7bd994d1644ad405b3395420ecaf",
+
+				DependencyNames: []DependencyName{},
+			}))
+
+			Expect(manifest.Release.Jobs[0]).To(Equal(Job{
+				Name: "powerdns",
+
+				VersionRaw: "MGI4MGIzYzE5OGJmN2FiYzZjODEyNjIwMTNkZTQ5NDM2OWZkMjViNg==",
+				Version:    "0b80b3c198bf7abc6c81262013de494369fd25b6",
+
+				FingerprintRaw: "MGI4MGIzYzE5OGJmN2FiYzZjODEyNjIwMTNkZTQ5NDM2OWZkMjViNg==",
+				Fingerprint:    "0b80b3c198bf7abc6c81262013de494369fd25b6",
+
+				SHA1Raw: "YWI5NzA5YmVhYjViZTBmYjYyYTJkMWYzYzg4ZDA2YzliNGJkZWM2NQ==",
+				SHA1:    "ab9709beab5be0fb62a2d1f3c88d06c9b4bdec65",
+			}))
+		})
+	})
+})

data/go/src/boshprovisioner/release/manifest/syntax_validator.go

@@ -0,0 +1,134 @@
+package manifest
+
+import (
+	"encoding/base64"
+
+	bosherr "bosh/errors"
+)
+
+// SyntaxValidator parses and saves all manifest values to determine
+// their syntactic validity. Determining if individual values make sense
+// in a greater context (within a full release) is outside of scope.
+type SyntaxValidator struct {
+	release *Release
+}
+
+func NewSyntaxValidator(manifest *Manifest) SyntaxValidator {
+	if manifest == nil {
+		panic("Expected manifest to not be nil")
+	}
+
+	return SyntaxValidator{release: &manifest.Release}
+}
+
+func (v SyntaxValidator) Validate() error {
+	if v.release.Name == "" {
+		return bosherr.New("Missing release name")
+	}
+
+	if v.release.Version == "" {
+		return bosherr.New("Missing release version")
+	}
+
+	if v.release.CommitHash == "" {
+		return bosherr.New("Missing release commit_hash")
+	}
+
+	for i, job := range v.release.Jobs {
+		err := v.validateJob(&v.release.Jobs[i])
+		if err != nil {
+			return bosherr.WrapError(err, "Job %s (%d)", job.Name, i)
+		}
+	}
+
+	for i, pkg := range v.release.Packages {
+		err := v.validatePkg(&v.release.Packages[i])
+		if err != nil {
+			return bosherr.WrapError(err, "Package %s (%d)", pkg.Name, i)
+		}
+	}
+
+	return nil
+}
+
+func (v SyntaxValidator) validateJob(job *Job) error {
+	if job.Name == "" {
+		return bosherr.New("Missing name")
+	}
+
+	if job.VersionRaw == "" {
+		return bosherr.New("Missing version")
+	}
+
+	bytes, err := base64.StdEncoding.DecodeString(job.VersionRaw)
+	if err != nil {
+		return bosherr.WrapError(err, "Decoding base64 encoded version")
+	}
+
+	job.Version = string(bytes)
+
+	if job.FingerprintRaw == "" {
+		return bosherr.New("Missing fingerprint")
+	}
+
+	bytes, err = base64.StdEncoding.DecodeString(job.FingerprintRaw)
+	if err != nil {
+		return bosherr.WrapError(err, "Decoding base64 encoded fingerprint")
+	}
+
+	job.Fingerprint = string(bytes)
+
+	if job.SHA1Raw == "" {
+		return bosherr.New("Missing sha1")
+	}
+
+	bytes, err = base64.StdEncoding.DecodeString(job.SHA1Raw)
+	if err != nil {
+		return bosherr.WrapError(err, "Decoding base64 encoded sha1")
+	}
+
+	job.SHA1 = string(bytes)
+
+	return nil
+}
+
+func (v SyntaxValidator) validatePkg(pkg *Package) error {
+	if pkg.Name == "" {
+		return bosherr.New("Missing name")
+	}
+
+	if pkg.VersionRaw == "" {
+		return bosherr.New("Missing version")
+	}
+
+	bytes, err := base64.StdEncoding.DecodeString(pkg.VersionRaw)
+	if err != nil {
+		return bosherr.WrapError(err, "Decoding base64 encoded version")
+	}
+
+	pkg.Version = string(bytes)
+
+	if pkg.FingerprintRaw == "" {
+		return bosherr.New("Missing fingerprint")
+	}
+
+	bytes, err = base64.StdEncoding.DecodeString(pkg.FingerprintRaw)
+	if err != nil {
+		return bosherr.WrapError(err, "Decoding base64 encoded fingerprint")
+	}
+
+	pkg.Fingerprint = string(bytes)
+
+	if pkg.SHA1Raw == "" {
+		return bosherr.New("Missing sha1")
+	}
+
+	bytes, err = base64.StdEncoding.DecodeString(pkg.SHA1Raw)
+	if err != nil {
+		return bosherr.WrapError(err, "Decoding base64 encoded sha1")
+	}
+
+	pkg.SHA1 = string(bytes)
+
+	return nil
+}

data/go/src/boshprovisioner/release/reader_factory.go

@@ -1,6 +1,8 @@
 package release
 
 import (
+	"strings"
+
 	boshlog "bosh/logger"
 	boshsys "bosh/system"
 
@@ -8,6 +10,10 @@ import (
 	bptar "boshprovisioner/tar"
 )
 
+const (
+	readerFactoryDirPrefix = "dir://"
+)
+
 type ReaderFactory struct {
 	downloader bpdload.Downloader
 	extractor  bptar.Extractor
@@ -29,6 +35,11 @@ func NewReaderFactory(
 	}
 }
 
-func (rf ReaderFactory) NewTarReader(path string) *TarReader {
-	return NewTarReader(path, rf.downloader, rf.extractor, rf.fs, rf.logger)
+func (rf ReaderFactory) NewReader(name, version, url string) Reader {
+	if strings.HasPrefix(url, readerFactoryDirPrefix) {
+		path := url[len(readerFactoryDirPrefix):]
+		return NewDirReader(name, version, path, rf.fs, rf.logger)
+	}
+
+	return NewTarReader(url, rf.downloader, rf.extractor, rf.fs, rf.logger)
 }

data/go/src/boshprovisioner/release/reader_interface.go

@@ -0,0 +1,6 @@
+package release
+
+type Reader interface {
+	Read() (Release, error)
+	Close() error
+}