vagrant-bosh 0.0.6 → 0.0.7

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

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

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

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

@@ -1,97 +0,0 @@
-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
-
-	drainer Drainer
-	stopper Stopper
-	applier bpapplier.Applier
-	starter Starter
-	waiter  Waiter
-
-	eventLog bpeventlog.Log
-	logger   boshlog.Logger
-}
-
-func NewUpdater(
-	instanceDesc string,
-	drainer Drainer,
-	stopper Stopper,
-	applier bpapplier.Applier,
-	starter Starter,
-	waiter Waiter,
-	eventLog bpeventlog.Log,
-	logger boshlog.Logger,
-) Updater {
-	return Updater{
-		instanceDesc: instanceDesc,
-
-		drainer: drainer,
-		stopper: stopper,
-		applier: applier,
-		starter: starter,
-		waiter:  waiter,
-
-		eventLog: eventLog,
-		logger:   logger,
-	}
-}
-
-func (u Updater) SetUp() error {
-	stage := u.eventLog.BeginStage(fmt.Sprintf("Setting up instance %s", u.instanceDesc), 3)
-
-	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
-}
-
-func (u Updater) TearDown() error {
-	stage := u.eventLog.BeginStage(fmt.Sprintf("Tearing down instance %s", u.instanceDesc), 2)
-
-	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")
-	}
-
-	return nil
-}

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

@@ -1,80 +0,0 @@
-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 {
-	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),
-		drainer,
-		stopper,
-		applier,
-		starter,
-		waiter,
-		f.eventLog,
-		f.logger,
-	)
-
-	return updater
-}

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

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

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

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

@@ -1,147 +0,0 @@
-package updater_test
-
-import (
-	"errors"
-	"time"
-
-	boshaction "bosh/agent/action"
-	boshlog "bosh/logger"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	fakebpagclient "boshprovisioner/agent/client/fakes"
-	. "boshprovisioner/instance/updater"
-)
-
-var _ = Describe("Waiter", func() {
-	var (
-		sleptTimes  []time.Duration
-		sleepFunc   func(d time.Duration)
-		agentClient *fakebpagclient.FakeClient
-		logger      boshlog.Logger
-		waiter      Waiter
-	)
-
-	const (
-		firstTimeGap      = 5000 * time.Millisecond
-		subsequentTimeGap = 1000 * time.Millisecond
-	)
-
-	BeforeEach(func() {
-		sleptTimes = []time.Duration{}
-		sleepFunc = func(d time.Duration) { sleptTimes = append(sleptTimes, d) }
-
-		agentClient = &fakebpagclient.FakeClient{}
-		logger = boshlog.NewLogger(boshlog.LevelNone)
-		waiter = NewWaiter(5000, 14000, sleepFunc, agentClient, logger)
-	})
-
-	Describe("Wait", func() {
-		Context("when agent reports its state as 'running' after some time", func() {
-			BeforeEach(func() {
-				agentClient.GetStateStates = []boshaction.GetStateV1ApplySpec{
-					boshaction.GetStateV1ApplySpec{JobState: "not-running"},
-					boshaction.GetStateV1ApplySpec{JobState: "not-running"},
-					boshaction.GetStateV1ApplySpec{JobState: "not-running"},
-					boshaction.GetStateV1ApplySpec{JobState: "not-running"},
-					boshaction.GetStateV1ApplySpec{JobState: "not-running"}, // 4
-					boshaction.GetStateV1ApplySpec{JobState: "running"},
-				}
-			})
-
-			It("waits for instance to become running checking every interval", func() {
-				err := waiter.Wait()
-				Expect(err).ToNot(HaveOccurred())
-
-				Expect(sleptTimes).To(Equal([]time.Duration{
-					firstTimeGap,
-					subsequentTimeGap,
-					subsequentTimeGap,
-					subsequentTimeGap,
-					subsequentTimeGap, // 4
-					subsequentTimeGap,
-				}))
-			})
-		})
-
-		Context("when agent does not report its state as 'running' after some time", func() {
-			BeforeEach(func() {
-				agentClient.GetStateState = boshaction.GetStateV1ApplySpec{JobState: "not-running"}
-			})
-
-			It("return error after trying as many times as possible", func() {
-				err := waiter.Wait()
-				Expect(err).To(Equal(ErrNotRunning))
-
-				Expect(sleptTimes).To(Equal([]time.Duration{
-					firstTimeGap,
-					subsequentTimeGap,
-					subsequentTimeGap,
-					subsequentTimeGap,
-					subsequentTimeGap, // 4
-					subsequentTimeGap,
-					subsequentTimeGap,
-					subsequentTimeGap,
-					subsequentTimeGap, // 8
-					subsequentTimeGap,
-				}))
-			})
-		})
-
-		Context("when agent state cannot be retrieved", func() {
-			BeforeEach(func() {
-				agentClient.GetStateErr = errors.New("fake-get-state-err")
-			})
-
-			It("returns error indicated failure to retrieve state", func() {
-				err := waiter.Wait()
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("fake-get-state-err"))
-
-				Expect(sleptTimes).To(Equal([]time.Duration{firstTimeGap}))
-			})
-		})
-
-		Context("when watch time is starts with a 0", func() {
-			BeforeEach(func() {
-				waiter = NewWaiter(0, 14000, sleepFunc, agentClient, logger)
-			})
-
-			BeforeEach(func() {
-				agentClient.GetStateStates = []boshaction.GetStateV1ApplySpec{
-					boshaction.GetStateV1ApplySpec{JobState: "not-running"},
-					boshaction.GetStateV1ApplySpec{JobState: "running"},
-				}
-			})
-
-			It("immediately checks if instance is running", func() {
-				err := waiter.Wait()
-				Expect(err).ToNot(HaveOccurred())
-
-				Expect(sleptTimes).To(Equal([]time.Duration{
-					0 * time.Millisecond,
-					subsequentTimeGap,
-				}))
-			})
-		})
-
-		Context("when watch time ends with a 0", func() {
-			BeforeEach(func() {
-				waiter = NewWaiter(0, 0, sleepFunc, agentClient, logger)
-			})
-
-			BeforeEach(func() {
-				agentClient.GetStateStates = []boshaction.GetStateV1ApplySpec{
-					boshaction.GetStateV1ApplySpec{JobState: "running"},
-				}
-			})
-
-			It("immediately checks if instance is running", func() {
-				err := waiter.Wait()
-				Expect(err).ToNot(HaveOccurred())
-
-				Expect(sleptTimes).To(Equal([]time.Duration{0 * time.Millisecond}))
-			})
-		})
-	})
-})