vagrant-bosh 0.0.1

data/go/src/boshprovisioner/instance/updater/applier/empty_state.go

@@ -0,0 +1,66 @@
+package applier
+
+import (
+	boshas "bosh/agent/applier/applyspec"
+
+	bpdep "boshprovisioner/deployment"
+)
+
+// EmptyState represents state for a VM
+// that should not be running any job templates.
+type EmptyState struct {
+	instance bpdep.Instance
+}
+
+func NewEmptyState(instance bpdep.Instance) EmptyState {
+	return EmptyState{instance: instance}
+}
+
+func (s EmptyState) AsApplySpec() boshas.V1ApplySpec {
+	var spec boshas.V1ApplySpec
+
+	jobName := s.instance.JobName
+	jobIndex := s.instance.Index
+
+	spec = boshas.V1ApplySpec{
+		ConfigurationHash: "fake-configuration-hash", // todo
+
+		Deployment: s.instance.DeploymentName,
+
+		JobSpec: boshas.JobSpec{
+			Name: &jobName,
+		},
+
+		Index: &jobIndex,
+
+		NetworkSpecs: s.buildNetworkSpecs(),
+
+		// todo find out whats here
+		ResourcePoolSpecs: s.buildResourcePoolSpecs(),
+	}
+
+	return spec
+}
+
+func (s EmptyState) buildNetworkSpecs() map[string]boshas.NetworkSpec {
+	specs := map[string]boshas.NetworkSpec{}
+
+	for _, netAssoc := range s.instance.NetworkAssociations {
+		netConfig := s.instance.NetworkConfigurationForNetworkAssociation(netAssoc)
+
+		specs[netAssoc.Network.Name] = boshas.NetworkSpec{
+			Fields: map[string]interface{}{
+				"type":    netAssoc.Network.Type,
+				"ip":      netConfig.IP,
+				"netmask": netConfig.Netmask,
+				"gateway": netConfig.Gateway,
+			},
+		}
+	}
+
+	return specs
+}
+
+func (s EmptyState) buildResourcePoolSpecs() map[string]interface{} {
+	return map[string]interface{}{}
+}

data/go/src/boshprovisioner/instance/updater/applier/job_state.go

@@ -0,0 +1,178 @@
+package applier
+
+import (
+	boshas "bosh/agent/applier/applyspec"
+	bosherr "bosh/errors"
+
+	bpdep "boshprovisioner/deployment"
+	bptplcomp "boshprovisioner/instance/templatescompiler"
+	bppkgscomp "boshprovisioner/packagescompiler"
+)
+
+// JobState represents state for a VM
+// that should be running 1+ job templates.
+type JobState struct {
+	depJob   bpdep.Job
+	instance bpdep.Instance
+
+	templatesCompiler bptplcomp.TemplatesCompiler
+	packagesCompiler  bppkgscomp.PackagesCompiler
+
+	emptyState EmptyState
+}
+
+func NewJobState(
+	depJob bpdep.Job,
+	instance bpdep.Instance,
+	templatesCompiler bptplcomp.TemplatesCompiler,
+	packagesCompiler bppkgscomp.PackagesCompiler,
+) JobState {
+	return JobState{
+		depJob:   depJob,
+		instance: instance,
+
+		templatesCompiler: templatesCompiler,
+		packagesCompiler:  packagesCompiler,
+
+		emptyState: NewEmptyState(instance),
+	}
+}
+
+func (s JobState) AsApplySpec() (boshas.V1ApplySpec, error) {
+	var err error
+
+	spec := s.emptyState.AsApplySpec()
+
+	// JobTemplateSpecs list templates names; however,
+	// actual template content would come from RenderedTemplatesArchiveSpec
+	spec.JobSpec.JobTemplateSpecs = s.buildJobTemplateSpecs()
+
+	// Package dependencies for all job templates
+	spec.PackageSpecs, err = s.buildPackageSpecs()
+	if err != nil {
+		return spec, err
+	}
+
+	// Provides content for JobTemplateSpecs
+	spec.RenderedTemplatesArchiveSpec, err = s.buildRenderedTemplatesArchive()
+	if err != nil {
+		return spec, err
+	}
+
+	return spec, nil
+}
+
+func (s JobState) buildJobTemplateSpecs() []boshas.JobTemplateSpec {
+	var specs []boshas.JobTemplateSpec
+
+	for _, template := range s.depJob.Templates {
+		spec := boshas.JobTemplateSpec{
+			Name:    template.Name,
+			Version: "fake-job-template-version", // todo
+
+			Sha1:        "", // deprecated
+			BlobstoreID: "", // deprecated
+		}
+
+		specs = append(specs, spec)
+	}
+
+	return specs
+}
+
+func (s JobState) buildPackageSpecs() (map[string]boshas.PackageSpec, error) {
+	specs := map[string]boshas.PackageSpec{}
+
+	for _, template := range s.depJob.Templates {
+		pkgs, err := s.templatesCompiler.FindPackages(template)
+		if err != nil {
+			return specs, bosherr.WrapError(err, "Finding packages for template %s", template.Name)
+		}
+
+		for _, pkg := range pkgs {
+			rec, err := s.packagesCompiler.FindCompiledPackage(pkg)
+			if err != nil {
+				return specs, bosherr.WrapError(err, "Finding compiled package %s", pkg.Name)
+			}
+
+			specs[pkg.Name] = boshas.PackageSpec{
+				Name:    pkg.Name,
+				Version: pkg.Version,
+
+				Sha1:        rec.SHA1,
+				BlobstoreID: rec.BlobID,
+			}
+		}
+	}
+
+	return specs, nil
+}
+
+func (s JobState) buildRenderedTemplatesArchive() (boshas.RenderedTemplatesArchiveSpec, error) {
+	var archive boshas.RenderedTemplatesArchiveSpec
+
+	rec, err := s.templatesCompiler.FindRenderedArchive(s.depJob, s.instance)
+	if err != nil {
+		return archive, bosherr.WrapError(
+			err, "Finding rendered archive %s", s.depJob.Name)
+	}
+
+	// todo uppercase Sha1
+	archive.Sha1 = rec.SHA1
+	archive.BlobstoreID = rec.BlobID
+
+	return archive, nil
+}
+
+/*
+// Example apply spec
+{
+  "job": {
+    "name": "router",
+    "template": "router template",
+    "version": "1.0",
+    "sha1": "router sha1",
+    "blobstore_id": "router-blob-id-1",
+    "templates": [{
+      "name": "template 1",
+      "version": "0.1",
+      "sha1": "template 1 sha1",
+      "blobstore_id": "template-blob-id-1"
+    }]
+  },
+
+  "index": 1,
+
+  "packages": {
+    "package 1": {
+      "name": "package 1",
+      "version": "0.1",
+      "sha1": "package 1 sha1",
+      "blobstore_id": "package-blob-id-1"
+    }
+  },
+
+  "networks": {
+    "manual-net": {
+      "ip": "xx.xx.xx.xx",
+      "gateway": "xx.xx.xx.xx",
+      "netmask": "xx.xx.xx.xx",
+      "dns": ["xx.xx.xx.xx"],
+      "default": ["dns", "gateway"],
+      "cloud_properties": {"subnet": "subnet-xxxxxx"},
+      "dns_record_name": "job-index.job-name.manual-net.deployment-name.bosh"
+    },
+    "vip-net": {
+      "type": "vip",
+      "ip": "xx.xx.xx.xx",
+      "cloud_properties": {"security_groups": ["bosh"]},
+      "dns_record_name": "job-index.job-name.vip-net.deployment-name.bosh"
+    }
+  },
+
+  "rendered_templates_archive": {
+    "sha1": "archive sha 1",
+    "blobstore_id": "archive-blob-id-1"
+  }
+}
+*/

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

@@ -0,0 +1,72 @@
+package updater
+
+import (
+	"math"
+	"time"
+
+	boshaction "bosh/agent/action"
+	boshas "bosh/agent/applier/applyspec"
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+
+	bpagclient "boshprovisioner/agent/client"
+)
+
+const drainerLogTag = "Drainer"
+
+type Drainer struct {
+	agentClient bpagclient.Client
+	logger      boshlog.Logger
+}
+
+func NewDrainer(
+	agentClient bpagclient.Client,
+	logger boshlog.Logger,
+) Drainer {
+	return Drainer{
+		agentClient: agentClient,
+		logger:      logger,
+	}
+}
+
+func (d Drainer) Drain() error {
+	d.logger.Debug(drainerLogTag, "Draining instance")
+
+	drainType := boshaction.DrainTypeUpdate
+	spec := boshas.V1ApplySpec{}
+
+	drainTime, err := d.agentClient.Drain(drainType, spec)
+	if err != nil {
+		return bosherr.WrapError(err, "Sending drain update")
+	}
+
+	if drainTime > 0 {
+		d.logger.Debug(drainerLogTag, "Waiting for static drain to finish")
+		time.Sleep(time.Duration(drainTime) * time.Second)
+		return nil
+	}
+
+	d.logger.Debug(drainerLogTag, "Waiting for dynamic drain to finish")
+
+	return d.waitForDynamicDrain(drainTime)
+}
+
+func (d Drainer) waitForDynamicDrain(drainTime int) error {
+	var err error
+
+	for {
+		waitTime := int(math.Abs(float64(drainTime)))
+		if waitTime > 0 {
+			time.Sleep(time.Duration(waitTime) * time.Second)
+		}
+
+		if drainTime >= 0 {
+			return nil
+		}
+
+		drainTime, err = d.agentClient.Drain(boshaction.DrainTypeStatus)
+		if err != nil {
+			return bosherr.WrapError(err, "Sending drain status")
+		}
+	}
+}

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

@@ -0,0 +1,39 @@
+package updater
+
+import (
+	boshas "bosh/agent/applier/applyspec"
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+
+	bpagclient "boshprovisioner/agent/client"
+)
+
+const preparerLogTag = "Preparer"
+
+type Preparer struct {
+	agentClient bpagclient.Client
+	logger      boshlog.Logger
+}
+
+func NewPreparer(
+	agentClient bpagclient.Client,
+	logger boshlog.Logger,
+) Preparer {
+	return Preparer{
+		agentClient: agentClient,
+		logger:      logger,
+	}
+}
+
+func (p Preparer) Prepare() error {
+	p.logger.Debug(preparerLogTag, "Preparing instance")
+
+	spec := boshas.V1ApplySpec{}
+
+	_, err := p.agentClient.Prepare(spec)
+	if err != nil {
+		return bosherr.WrapError(err, "Sending prepare")
+	}
+
+	return nil
+}

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

@@ -0,0 +1,36 @@
+package updater
+
+import (
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+
+	bpagclient "boshprovisioner/agent/client"
+)
+
+const starterLogTag = "Starter"
+
+type Starter struct {
+	agentClient bpagclient.Client
+	logger      boshlog.Logger
+}
+
+func NewStarter(
+	agentClient bpagclient.Client,
+	logger boshlog.Logger,
+) Starter {
+	return Starter{
+		agentClient: agentClient,
+		logger:      logger,
+	}
+}
+
+func (s Starter) Start() error {
+	s.logger.Debug(starterLogTag, "Starting instance")
+
+	_, err := s.agentClient.Start()
+	if err != nil {
+		return bosherr.WrapError(err, "Starting")
+	}
+
+	return nil
+}

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

@@ -0,0 +1,36 @@
+package updater
+
+import (
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+
+	bpagclient "boshprovisioner/agent/client"
+)
+
+const stopperLogTag = "Stopper"
+
+type Stopper struct {
+	agentClient bpagclient.Client
+	logger      boshlog.Logger
+}
+
+func NewStopper(
+	agentClient bpagclient.Client,
+	logger boshlog.Logger,
+) Stopper {
+	return Stopper{
+		agentClient: agentClient,
+		logger:      logger,
+	}
+}
+
+func (s Stopper) Stop() error {
+	s.logger.Debug(stopperLogTag, "Stopping instance")
+
+	_, err := s.agentClient.Stop()
+	if err != nil {
+		return bosherr.WrapError(err, "Stopping")
+	}
+
+	return nil
+}

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

@@ -0,0 +1,102 @@
+package updater
+
+import (
+	"fmt"
+
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+
+	bpeventlog "boshprovisioner/eventlog"
+	bpapplier "boshprovisioner/instance/updater/applier"
+)
+
+const updaterLogTag = "Updater"
+
+type Updater struct {
+	instanceDesc string
+
+	preparer Preparer
+	drainer  Drainer
+	stopper  Stopper
+	applier  bpapplier.Applier
+	starter  Starter
+	waiter   Waiter
+
+	eventLog bpeventlog.Log
+	logger   boshlog.Logger
+}
+
+func NewUpdater(
+	instanceDesc string,
+	preparer Preparer,
+	drainer Drainer,
+	stopper Stopper,
+	applier bpapplier.Applier,
+	starter Starter,
+	waiter Waiter,
+	eventLog bpeventlog.Log,
+	logger boshlog.Logger,
+) Updater {
+	return Updater{
+		instanceDesc: instanceDesc,
+
+		preparer: preparer,
+		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)
+
+	task := stage.BeginTask("Preparing")
+
+	err := task.End(u.preparer.Prepare())
+	if err != nil {
+		return bosherr.WrapError(err, "Preparing")
+	}
+
+	task = stage.BeginTask("Draining")
+
+	err = task.End(u.drainer.Drain())
+	if err != nil {
+		return bosherr.WrapError(err, "Draining")
+	}
+
+	task = stage.BeginTask("Stopping")
+
+	err = task.End(u.stopper.Stop())
+	if err != nil {
+		return bosherr.WrapError(err, "Stopping")
+	}
+
+	task = stage.BeginTask("Applying")
+
+	err = task.End(u.applier.Apply())
+	if err != nil {
+		return bosherr.WrapError(err, "Applying")
+	}
+
+	task = stage.BeginTask("Starting")
+
+	err = task.End(u.starter.Start())
+	if err != nil {
+		return bosherr.WrapError(err, "Starting")
+	}
+
+	task = stage.BeginTask("Waiting")
+
+	err = task.End(u.waiter.Wait())
+	if err != nil {
+		return bosherr.WrapError(err, "Waiting")
+	}
+
+	return nil
+}

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

@@ -0,0 +1,83 @@
+package updater
+
+import (
+	"fmt"
+	"time"
+
+	boshlog "bosh/logger"
+
+	bpagclient "boshprovisioner/agent/client"
+	bpdep "boshprovisioner/deployment"
+	bpeventlog "boshprovisioner/eventlog"
+	bptplcomp "boshprovisioner/instance/templatescompiler"
+	bpapplier "boshprovisioner/instance/updater/applier"
+	bppkgscomp "boshprovisioner/packagescompiler"
+)
+
+type UpdaterFactory struct {
+	templatesCompiler       bptplcomp.TemplatesCompiler
+	packagesCompilerFactory bppkgscomp.ConcretePackagesCompilerFactory
+
+	eventLog bpeventlog.Log
+	logger   boshlog.Logger
+}
+
+func NewUpdaterFactory(
+	templatesCompiler bptplcomp.TemplatesCompiler,
+	packagesCompilerFactory bppkgscomp.ConcretePackagesCompilerFactory,
+	eventLog bpeventlog.Log,
+	logger boshlog.Logger,
+) UpdaterFactory {
+	return UpdaterFactory{
+		templatesCompiler:       templatesCompiler,
+		packagesCompilerFactory: packagesCompilerFactory,
+
+		eventLog: eventLog,
+		logger:   logger,
+	}
+}
+
+func (f UpdaterFactory) NewUpdater(
+	agentClient bpagclient.Client,
+	depJob bpdep.Job,
+	instance bpdep.Instance,
+) Updater {
+	preparer := NewPreparer(agentClient, f.logger)
+
+	drainer := NewDrainer(agentClient, f.logger)
+
+	stopper := NewStopper(agentClient, f.logger)
+
+	applier := bpapplier.NewApplier(
+		depJob,
+		instance,
+		f.templatesCompiler,
+		f.packagesCompilerFactory.NewCompiler(agentClient),
+		agentClient,
+		f.logger,
+	)
+
+	starter := NewStarter(agentClient, f.logger)
+
+	waiter := NewWaiter(
+		instance.WatchTime.Start(),
+		instance.WatchTime.End(),
+		time.Sleep,
+		agentClient,
+		f.logger,
+	)
+
+	updater := NewUpdater(
+		fmt.Sprintf("%s/%d", instance.JobName, instance.Index),
+		preparer,
+		drainer,
+		stopper,
+		applier,
+		starter,
+		waiter,
+		f.eventLog,
+		f.logger,
+	)
+
+	return updater
+}

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

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

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

@@ -0,0 +1,77 @@
+package updater
+
+import (
+	"time"
+
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+
+	bpagclient "boshprovisioner/agent/client"
+)
+
+const waiterLogTag = "Waiter"
+
+var (
+	ErrNotRunning = bosherr.New("Instance did not reach running state")
+)
+
+type Waiter struct {
+	watchSchedule []time.Duration
+	sleepFunc     SleepFunc
+	agentClient   bpagclient.Client
+	logger        boshlog.Logger
+}
+
+type SleepFunc func(time.Duration)
+
+func NewWaiter(
+	startWatchTime int,
+	endWatchTime int,
+	sleepFunc SleepFunc,
+	agentClient bpagclient.Client,
+	logger boshlog.Logger,
+) Waiter {
+	return Waiter{
+		watchSchedule: buildWatchSchedule(startWatchTime, endWatchTime),
+		sleepFunc:     sleepFunc,
+		agentClient:   agentClient,
+		logger:        logger,
+	}
+}
+
+// Wait waits for an instance to reach running state.
+// It polls agent based on a watch schedule and inspects its job state.
+func (w Waiter) Wait() error {
+	w.logger.Debug(waiterLogTag, "Waiting for instance to reach running state")
+	w.logger.Debug(waiterLogTag, "Using schedule %v", w.watchSchedule)
+
+	for _, timeGap := range w.watchSchedule {
+		w.logger.Debug(waiterLogTag, "Sleeping for %v", timeGap)
+		w.sleepFunc(timeGap)
+
+		state, err := w.agentClient.GetState()
+		if err != nil {
+			return bosherr.WrapError(err, "Sending get_state")
+		}
+
+		// todo stopped state
+		if state.JobState == "running" {
+			return nil
+		}
+	}
+
+	return ErrNotRunning
+}
+
+// buildWatchSchedule returns list of millisecond interval
+// at which instance should be checked for its running state.
+// ([3000, 1000, 1000] =~ wait for 3000ms, then 1000ms, and 1000ms again)
+func buildWatchSchedule(start, end int) []time.Duration {
+	timeGaps := []time.Duration{time.Duration(start) * time.Millisecond}
+
+	for total := start; total < end; total += 1000 {
+		timeGaps = append(timeGaps, 1000*time.Millisecond)
+	}
+
+	return timeGaps
+}