vagrant-bosh 0.0.2 → 0.0.3

data/dev/Vagrantfile

@@ -24,7 +24,7 @@ Vagrant.configure("2") do |config|
   end
 
   config.vm.provision "bosh" do |c|
-    c.manifest = `cat example-bosh-manifest.yml`
-    # c.manifest = `cat example-winston-manifest.yml`
+    # c.manifest = `cat example-bosh-manifest.yml`
+    c.manifest = `cat example-winston-manifest.yml`
   end
 end

data/dev/example-winston-manifest.yml

@@ -2,8 +2,8 @@ name: room101
 
 releases:
 - name: room101
-  version: 0.1-dev
-  url: file:///vagrant/room101-0.1-dev.tgz
+  version: 0+dev.3
+  url: file:///vagrant/room101-0+dev.3.tgz
 
 networks:
 - name: room101
@@ -42,12 +42,9 @@ jobs:
     winston:
       config:
         jobs:
-        - name: bosh_unit
-          privileged: true
-          build: ci/bosh_unit.yml
-          inputs:
-          - resource: ci
-          - resource: bosh-repo
+        - name: nothing
+          image: ubuntu
+          script: "echo works"
 
       prole:
         address: 127.0.0.1:4637

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

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

@@ -0,0 +1,48 @@
+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/updater/updater.go

@@ -15,12 +15,11 @@ const updaterLogTag = "Updater"
 type Updater struct {
 	instanceDesc string
 
-	preparer Preparer
-	drainer  Drainer
-	stopper  Stopper
-	applier  bpapplier.Applier
-	starter  Starter
-	waiter   Waiter
+	drainer Drainer
+	stopper Stopper
+	applier bpapplier.Applier
+	starter Starter
+	waiter  Waiter
 
 	eventLog bpeventlog.Log
 	logger   boshlog.Logger
@@ -28,7 +27,6 @@ type Updater struct {
 
 func NewUpdater(
 	instanceDesc string,
-	preparer Preparer,
 	drainer Drainer,
 	stopper Stopper,
 	applier bpapplier.Applier,
@@ -40,62 +38,59 @@ func NewUpdater(
 	return Updater{
 		instanceDesc: instanceDesc,
 
-		preparer: preparer,
-		drainer:  drainer,
-		stopper:  stopper,
-		applier:  applier,
-		starter:  starter,
-		waiter:   waiter,
+		drainer: drainer,
+		stopper: stopper,
+		applier: applier,
+		starter: starter,
+		waiter:  waiter,
 
 		eventLog: eventLog,
 		logger:   logger,
 	}
 }
 
-func (u Updater) Update() error {
-	stage := u.eventLog.BeginStage(
-		fmt.Sprintf("Updating instance %s", u.instanceDesc), 6)
+func (u Updater) SetUp() error {
+	stage := u.eventLog.BeginStage(fmt.Sprintf("Setting up instance %s", u.instanceDesc), 3)
 
-	task := stage.BeginTask("Preparing")
+	task := stage.BeginTask("Applying")
 
-	err := task.End(u.preparer.Prepare())
+	err := task.End(u.applier.Apply())
 	if err != nil {
-		return bosherr.WrapError(err, "Preparing")
+		return bosherr.WrapError(err, "Applying")
 	}
 
-	task = stage.BeginTask("Draining")
+	task = stage.BeginTask("Starting")
 
-	err = task.End(u.drainer.Drain())
+	err = task.End(u.starter.Start())
 	if err != nil {
-		return bosherr.WrapError(err, "Draining")
+		return bosherr.WrapError(err, "Starting")
 	}
 
-	task = stage.BeginTask("Stopping")
+	task = stage.BeginTask("Waiting")
 
-	err = task.End(u.stopper.Stop())
+	err = task.End(u.waiter.Wait())
 	if err != nil {
-		return bosherr.WrapError(err, "Stopping")
+		return bosherr.WrapError(err, "Waiting")
 	}
 
-	task = stage.BeginTask("Applying")
+	return nil
+}
 
-	err = task.End(u.applier.Apply())
-	if err != nil {
-		return bosherr.WrapError(err, "Applying")
-	}
+func (u Updater) TearDown() error {
+	stage := u.eventLog.BeginStage(fmt.Sprintf("Tearing down instance %s", u.instanceDesc), 2)
 
-	task = stage.BeginTask("Starting")
+	task := stage.BeginTask("Draining")
 
-	err = task.End(u.starter.Start())
+	err := task.End(u.drainer.Drain())
 	if err != nil {
-		return bosherr.WrapError(err, "Starting")
+		return bosherr.WrapError(err, "Draining")
 	}
 
-	task = stage.BeginTask("Waiting")
+	task = stage.BeginTask("Stopping")
 
-	err = task.End(u.waiter.Wait())
+	err = task.End(u.stopper.Stop())
 	if err != nil {
-		return bosherr.WrapError(err, "Waiting")
+		return bosherr.WrapError(err, "Stopping")
 	}
 
 	return nil

data/go/src/boshprovisioner/instance/updater/updater_factory.go

@@ -42,8 +42,6 @@ func (f UpdaterFactory) NewUpdater(
 	depJob bpdep.Job,
 	instance bpdep.Instance,
 ) Updater {
-	preparer := NewPreparer(agentClient, f.logger)
-
 	drainer := NewDrainer(agentClient, f.logger)
 
 	stopper := NewStopper(agentClient, f.logger)
@@ -69,7 +67,6 @@ func (f UpdaterFactory) NewUpdater(
 
 	updater := NewUpdater(
 		fmt.Sprintf("%s/%d", instance.JobName, instance.Index),
-		preparer,
 		drainer,
 		stopper,
 		applier,

data/go/src/boshprovisioner/main/config.go

@@ -7,6 +7,7 @@ import (
 	boshsys "bosh/system"
 
 	bpprov "boshprovisioner/provisioner"
+	bpvm "boshprovisioner/vm"
 )
 
 type Config struct {
@@ -24,6 +25,8 @@ type Config struct {
 	Mbus string `json:"mbus"`
 
 	Blobstore bpprov.BlobstoreConfig `json:"blobstore"`
+
+	VMProvisioner bpvm.VMProvisionerConfig `json:"vm_provisioner"`
 }
 
 func NewConfigFromPath(path string, fs boshsys.FileSystem) (Config, error) {

data/go/src/boshprovisioner/main/main.go

@@ -12,6 +12,7 @@ import (
 	bpdep "boshprovisioner/deployment"
 	bpdload "boshprovisioner/downloader"
 	bpeventlog "boshprovisioner/eventlog"
+	bpinstance "boshprovisioner/instance"
 	bptplcomp "boshprovisioner/instance/templatescompiler"
 	bpinstupd "boshprovisioner/instance/updater"
 	bppkgscomp "boshprovisioner/packagescompiler"
@@ -19,7 +20,7 @@ import (
 	bprel "boshprovisioner/release"
 	bpreljob "boshprovisioner/release/job"
 	bptar "boshprovisioner/tar"
-	bpvm "boshprovisioner/vm"
+	bpvagrantvm "boshprovisioner/vm/vagrant"
 )
 
 const mainLogTag = "main"
@@ -126,37 +127,38 @@ func main() {
 
 	deploymentReaderFactory := bpdep.NewReaderFactory(fs, logger)
 
-	vmProvisionerFactory := bpvm.NewVMProvisionerFactory(
+	vagrantVMProvisionerFactory := bpvagrantvm.NewVMProvisionerFactory(
 		fs,
 		runner,
 		config.AssetsDir,
 		config.Mbus,
 		config.Blobstore.AsMap(),
+		config.VMProvisioner,
 		eventLog,
 		logger,
 	)
 
-	vmProvisioner := vmProvisionerFactory.NewVMProvisioner()
+	vagrantVMProvisioner := vagrantVMProvisionerFactory.NewVMProvisioner()
 
 	releaseCompiler := bpprov.NewReleaseCompiler(
 		reposFactory.NewBlobstoreReleasesRepo(),
 		releaseReaderFactory,
 		packagesCompilerFactory,
 		templatesCompiler,
-		vmProvisioner,
+		vagrantVMProvisioner,
 		eventLog,
 		logger,
 	)
 
-	instanceProvisioner := bpprov.NewInstanceProvisioner(
+	instanceProvisioner := bpinstance.NewInstanceProvisioner(
 		updaterFactory,
-		vmProvisioner,
 		logger,
 	)
 
 	deploymentProvisioner := bpprov.NewDeploymentProvisioner(
 		config.ManifestPath,
 		deploymentReaderFactory,
+		vagrantVMProvisioner,
 		releaseCompiler,
 		instanceProvisioner,
 		eventLog,

data/go/src/boshprovisioner/provisioner/deployment_provisioner.go

@@ -6,6 +6,8 @@ import (
 
 	bpdep "boshprovisioner/deployment"
 	bpeventlog "boshprovisioner/eventlog"
+	bpinstance "boshprovisioner/instance"
+	bpvm "boshprovisioner/vm"
 )
 
 const deploymentProvisionerLogTag = "DeploymentProvisioner"
@@ -16,8 +18,9 @@ type DeploymentProvisioner struct {
 	manifestPath            string
 	deploymentReaderFactory bpdep.ReaderFactory
 
+	vmProvisioner       bpvm.VMProvisioner
 	releaseCompiler     ReleaseCompiler
-	instanceProvisioner InstanceProvisioner
+	instanceProvisioner bpinstance.InstanceProvisioner
 
 	eventLog bpeventlog.Log
 	logger   boshlog.Logger
@@ -26,8 +29,9 @@ type DeploymentProvisioner struct {
 func NewDeploymentProvisioner(
 	manifestPath string,
 	deploymentReaderFactory bpdep.ReaderFactory,
+	vmProvisioner bpvm.VMProvisioner,
 	releaseCompiler ReleaseCompiler,
-	instanceProvisioner InstanceProvisioner,
+	instanceProvisioner bpinstance.InstanceProvisioner,
 	eventLog bpeventlog.Log,
 	logger boshlog.Logger,
 ) DeploymentProvisioner {
@@ -35,6 +39,7 @@ func NewDeploymentProvisioner(
 		manifestPath:            manifestPath,
 		deploymentReaderFactory: deploymentReaderFactory,
 
+		vmProvisioner:       vmProvisioner,
 		releaseCompiler:     releaseCompiler,
 		instanceProvisioner: instanceProvisioner,
 
@@ -57,21 +62,47 @@ func (p DeploymentProvisioner) Provision() error {
 
 	task = stage.BeginTask("Validating instance")
 
-	job, instance, err := p.validateInstance(deployment)
+	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")
 	}
 
-	err = p.instanceProvisioner.Provision(job, instance)
+	vm, err = p.vmProvisioner.Provision(depInstance)
 	if err != nil {
-		return bosherr.WrapError(err, "Provisioning instance")
+		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
 }
 

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

@@ -59,6 +59,8 @@ func (p ReleaseCompiler) Compile(instance bpdep.Instance, releases []bpdep.Relea
 		return bosherr.WrapError(err, "Provisioning agent")
 	}
 
+	defer vm.Deprovision()
+
 	err = p.uploadReleases(releases)
 	if err != nil {
 		return bosherr.WrapError(err, "Uploading releases")

data/go/src/boshprovisioner/vm/{agent_provisioner.go → vagrant/agent_provisioner.go}

@@ -87,7 +87,7 @@ func (p AgentProvisioner) Provision(instance bpdep.Instance) (bpagclient.Client,
 
 	task = stage.BeginTask("Starting")
 
-	err = task.End(p.runitProvisioner.Provision("agent"))
+	err = task.End(p.runitProvisioner.Provision("agent", 10*time.Second))
 	if err != nil {
 		return nil, bosherr.WrapError(err, "Provisioning agent with runit")
 	}