vagrant-bosh 0.0.6 → 0.0.7

data/go/src/boshprovisioner/provisioner/blobstore_provisioner.go

@@ -1,38 +0,0 @@
-package provisioner
-
-import (
-	"os"
-
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-)
-
-type BlobstoreProvisioner struct {
-	fs              boshsys.FileSystem
-	blobstoreConfig BlobstoreConfig
-	logger          boshlog.Logger
-}
-
-func NewBlobstoreProvisioner(
-	fs boshsys.FileSystem,
-	blobstoreConfig BlobstoreConfig,
-	logger boshlog.Logger,
-) BlobstoreProvisioner {
-	return BlobstoreProvisioner{
-		fs:              fs,
-		blobstoreConfig: blobstoreConfig,
-		logger:          logger,
-	}
-}
-
-func (p BlobstoreProvisioner) Provision() error {
-	blobstorePath := p.blobstoreConfig.LocalPath()
-	if blobstorePath != "" {
-		err := p.fs.MkdirAll(blobstorePath, os.ModeDir)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

data/go/src/boshprovisioner/provisioner/deployment_provisioner_interface.go

@@ -1,10 +0,0 @@
-package provisioner
-
-type DeploymentProvisioner interface {
-	Provision() error
-}
-
-type DeploymentProvisionerConfig struct {
-	// If manifest path is empty, release compilation and job provisioning will be skipped
-	ManifestPath string `json:"manifest_path"`
-}

data/go/src/boshprovisioner/provisioner/release_compiler.go

@@ -1,95 +0,0 @@
-package provisioner
-
-import (
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-
-	bpdep "boshprovisioner/deployment"
-	bpeventlog "boshprovisioner/eventlog"
-	bptplcomp "boshprovisioner/instance/templatescompiler"
-	bppkgscomp "boshprovisioner/packagescompiler"
-	bprel "boshprovisioner/release"
-	bpvm "boshprovisioner/vm"
-)
-
-const releaseCompilerLogTag = "ReleaseCompiler"
-
-type ReleaseCompiler struct {
-	releaseReaderFactory bprel.ReaderFactory
-
-	packagesCompilerFactory bppkgscomp.ConcretePackagesCompilerFactory
-	templatesCompiler       bptplcomp.TemplatesCompiler
-
-	vmProvisioner bpvm.VMProvisioner
-
-	eventLog bpeventlog.Log
-	logger   boshlog.Logger
-}
-
-func NewReleaseCompiler(
-	releaseReaderFactory bprel.ReaderFactory,
-	packagesCompilerFactory bppkgscomp.ConcretePackagesCompilerFactory,
-	templatesCompiler bptplcomp.TemplatesCompiler,
-	vmProvisioner bpvm.VMProvisioner,
-	eventLog bpeventlog.Log,
-	logger boshlog.Logger,
-) ReleaseCompiler {
-	return ReleaseCompiler{
-		releaseReaderFactory: releaseReaderFactory,
-
-		packagesCompilerFactory: packagesCompilerFactory,
-		templatesCompiler:       templatesCompiler,
-
-		vmProvisioner: vmProvisioner,
-
-		eventLog: eventLog,
-		logger:   logger,
-	}
-}
-
-func (p ReleaseCompiler) Compile(instance bpdep.Instance, depReleases []bpdep.Release) error {
-	vm, err := p.vmProvisioner.Provision(instance)
-	if err != nil {
-		return bosherr.WrapError(err, "Provisioning VM")
-	}
-
-	defer vm.Deprovision()
-
-	pkgsCompiler := p.packagesCompilerFactory.NewCompiler(vm.AgentClient())
-
-	for _, depRelease := range depReleases {
-		err := p.compileRelease(pkgsCompiler, depRelease)
-		if err != nil {
-			return bosherr.WrapError(err, "Release %s", depRelease.Name)
-		}
-	}
-
-	return nil
-}
-
-func (p ReleaseCompiler) compileRelease(pkgsCompiler bppkgscomp.PackagesCompiler, depRelease bpdep.Release) error {
-	relReader := p.releaseReaderFactory.NewReader(
-		depRelease.Name,
-		depRelease.Version,
-		depRelease.URL,
-	)
-
-	relRelease, err := relReader.Read()
-	if err != nil {
-		return bosherr.WrapError(err, "Reading release")
-	}
-
-	defer relReader.Close()
-
-	err = pkgsCompiler.Compile(relRelease)
-	if err != nil {
-		return bosherr.WrapError(err, "Compiling release packages")
-	}
-
-	err = p.templatesCompiler.Precompile(relRelease)
-	if err != nil {
-		return bosherr.WrapError(err, "Precompiling release job templates")
-	}
-
-	return nil
-}

data/go/src/boshprovisioner/provisioner/single_configured_vm_provisioner.go

@@ -1,124 +0,0 @@
-package provisioner
-
-import (
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-
-	bpdep "boshprovisioner/deployment"
-	bpeventlog "boshprovisioner/eventlog"
-	bpinstance "boshprovisioner/instance"
-	bpvm "boshprovisioner/vm"
-)
-
-// SingleConfiguredVMProvisioner interprets deployment manifest and
-// configures 1 VM just like regular BOSH VM.
-type SingleConfiguredVMProvisioner struct {
-	manifestPath            string
-	deploymentReaderFactory bpdep.ReaderFactory
-
-	vmProvisioner       bpvm.VMProvisioner
-	releaseCompiler     ReleaseCompiler
-	instanceProvisioner bpinstance.InstanceProvisioner
-
-	eventLog bpeventlog.Log
-	logger   boshlog.Logger
-}
-
-func NewSingleConfiguredVMProvisioner(
-	manifestPath string,
-	deploymentReaderFactory bpdep.ReaderFactory,
-	vmProvisioner bpvm.VMProvisioner,
-	releaseCompiler ReleaseCompiler,
-	instanceProvisioner bpinstance.InstanceProvisioner,
-	eventLog bpeventlog.Log,
-	logger boshlog.Logger,
-) SingleConfiguredVMProvisioner {
-	return SingleConfiguredVMProvisioner{
-		manifestPath:            manifestPath,
-		deploymentReaderFactory: deploymentReaderFactory,
-
-		vmProvisioner:       vmProvisioner,
-		releaseCompiler:     releaseCompiler,
-		instanceProvisioner: instanceProvisioner,
-
-		eventLog: eventLog,
-		logger:   logger,
-	}
-}
-
-func (p SingleConfiguredVMProvisioner) Provision() error {
-	stage := p.eventLog.BeginStage("Setting up instance", 2)
-
-	reader := p.deploymentReaderFactory.NewManifestReader(p.manifestPath)
-
-	task := stage.BeginTask("Reading deployment manifest")
-
-	deployment, err := reader.Read()
-	if task.End(err) != nil {
-		return bosherr.WrapError(err, "Reading deployment")
-	}
-
-	task = stage.BeginTask("Validating instance")
-
-	job, depInstance, err := p.validateInstance(deployment)
-	if task.End(err) != nil {
-		return bosherr.WrapError(err, "Validating instance")
-	}
-
-	// todo VM was possibly provisioned last time
-	vm, err := p.vmProvisioner.Provision(depInstance)
-	if err != nil {
-		return bosherr.WrapError(err, "Provisioning VM")
-	}
-
-	instance := p.instanceProvisioner.PreviouslyProvisioned(vm.AgentClient(), job, depInstance)
-
-	err = instance.Deprovision()
-	if err != nil {
-		return bosherr.WrapError(err, "Deprovisioning instance")
-	}
-
-	// Deprovision VM before using release compiler since it will try to provision its own VM
-	err = vm.Deprovision()
-	if err != nil {
-		return bosherr.WrapError(err, "Deprovisioning VM")
-	}
-
-	err = p.releaseCompiler.Compile(deployment.CompilationInstance, deployment.Releases)
-	if err != nil {
-		return bosherr.WrapError(err, "Compiling releases")
-	}
-
-	vm, err = p.vmProvisioner.Provision(depInstance)
-	if err != nil {
-		return bosherr.WrapError(err, "Provisioning VM")
-	}
-
-	_, err = p.instanceProvisioner.Provision(vm.AgentClient(), job, depInstance)
-	if err != nil {
-		return bosherr.WrapError(err, "Starting instance")
-	}
-
-	// Do not Deprovision() VM to keep instance running
-
-	return nil
-}
-
-func (p SingleConfiguredVMProvisioner) validateInstance(deployment bpdep.Deployment) (bpdep.Job, bpdep.Instance, error) {
-	var job bpdep.Job
-	var instance bpdep.Instance
-
-	if len(deployment.Jobs) > 1 {
-		return job, instance, bosherr.New("Must have exactly 1 job")
-	}
-
-	job = deployment.Jobs[0]
-
-	if len(job.Instances) != 1 {
-		return job, instance, bosherr.New("Must have exactly 1 instance")
-	}
-
-	instance = job.Instances[0]
-
-	return job, instance, nil
-}

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

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

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

@@ -1,146 +0,0 @@
-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) {
-	devBuilds := filepath.Join(r.dir, ".dev_builds")
-	finalBuilds := filepath.Join(r.dir, ".final_builds")
-
-	for i, job := range release.Jobs {
-		fileName := job.Fingerprint + ".tgz"
-
-		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"
-
-		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 ""
-	}
-}
-
-/*
-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
-*/