vagrant-bosh 0.0.1

data/go/src/boshprovisioner/deployment/manifest/deployment.go

@@ -0,0 +1,80 @@
+package manifest
+
+import (
+	"encoding/json"
+
+	bosherr "bosh/errors"
+)
+
+func (d Deployment) InstanceWatchTime(job Job, i int) WatchTime {
+	var canaries int
+
+	if job.Update.Canaries != nil {
+		canaries = *job.Update.Canaries
+	} else if d.Update.Canaries != nil {
+		canaries = *d.Update.Canaries
+	}
+
+	if canaries > i {
+		return d.CanaryWatchTime(job)
+	}
+
+	return d.CanaryWatchTime(job)
+}
+
+func (d Deployment) CanaryWatchTime(job Job) WatchTime {
+	if job.Update.CanaryWatchTime != nil {
+		return *job.Update.CanaryWatchTime
+	} else if d.Update.CanaryWatchTime != nil {
+		return *d.Update.CanaryWatchTime
+	}
+
+	return DefaultWatchTime
+}
+
+func (d Deployment) UpdateWatchTime(job Job) WatchTime {
+	if job.Update.UpdateWatchTime != nil {
+		return *job.Update.UpdateWatchTime
+	} else if d.Update.UpdateWatchTime != nil {
+		return *d.Update.UpdateWatchTime
+	}
+
+	return DefaultWatchTime
+}
+
+func (d Deployment) InstanceProperties(job Job, i int) Properties {
+	result, err := job.deepCopyProperties()
+	if err != nil {
+		panic("Deep copying job properties")
+	}
+
+	for name, value := range d.Properties {
+		if _, ok := result[name]; !ok {
+			result[name] = value
+		}
+	}
+
+	return result
+}
+
+// deepCopyJobProperties makes a deep copy of job properties.
+// Always returns an initialized map even if job properties are nil.
+func (j Job) deepCopyProperties() (Properties, error) {
+	result := map[string]interface{}{}
+
+	if j.Properties == nil {
+		return result, nil
+	}
+
+	bytes, err := json.Marshal(j.Properties)
+	if err != nil {
+		return result, bosherr.WrapError(err, "Marshalling job properties")
+	}
+
+	err = json.Unmarshal(bytes, &result)
+	if err != nil {
+		return result, bosherr.WrapError(err, "Unmarshalling job properties")
+	}
+
+	return result, nil
+}

data/go/src/boshprovisioner/deployment/manifest/ips.go

@@ -0,0 +1,23 @@
+package manifest
+
+import (
+	gonet "net"
+	"strings"
+
+	bosherr "bosh/errors"
+)
+
+func NewIPsFromStrings(strs []string) ([]gonet.IP, error) {
+	var ips []gonet.IP
+
+	for _, str := range strs {
+		ip := gonet.ParseIP(strings.Trim(str, " "))
+		if ip == nil {
+			return ips, bosherr.New("Parsing IP %s", str)
+		}
+
+		ips = append(ips, ip)
+	}
+
+	return ips, nil
+}

data/go/src/boshprovisioner/deployment/manifest/manifest.go

@@ -0,0 +1,143 @@
+// Package manifest represents structure
+// of a user entered YAML deployment manifest.
+package manifest
+
+import (
+	gonet "net"
+
+	bosherr "bosh/errors"
+	boshsys "bosh/system"
+	"github.com/fraenkel/candiedyaml"
+)
+
+type Manifest struct {
+	Deployment Deployment
+}
+
+type Deployment struct {
+	Name string `yaml:"name"`
+
+	Releases []Release `yaml:"releases"`
+
+	Networks []Network `yaml:"networks"`
+
+	Compilation Compilation `yaml:"compilation"`
+
+	// Deployment-wide update config can be
+	// overwritten by job-specific update config
+	Update Update `yaml:"update"`
+
+	Jobs []Job `yaml:"jobs"`
+
+	// Global properties.
+	// Non-raw field is populated by the validator.
+	PropertiesRaw map[interface{}]interface{} `yaml:"properties"`
+	Properties    Properties
+}
+
+type Release struct {
+	Name    string `yaml:"name"`
+	Version string `yaml:"version"`
+
+	// Not offical BOSH manifest construct
+	URL string `yaml:"url"`
+}
+
+const (
+	NetworkTypeManual  = "manual"
+	NetworkTypeDynamic = "dynamic"
+	NetworkTypeVip     = "vip"
+)
+
+var NetworkTypes = []string{NetworkTypeManual, NetworkTypeDynamic, NetworkTypeVip}
+
+type Network struct {
+	Name string `yaml:"name"`
+
+	// e.g. manual, dynamic, vip
+	Type string `yaml:"type"`
+}
+
+type Compilation struct {
+	NetworkName string `yaml:"network"`
+}
+
+type Job struct {
+	Name      string `yaml:"name"`
+	Instances int    `yaml:"instances"`
+
+	Update Update `yaml:"update"`
+
+	// Deprecated in favor of Templates
+	Template interface{} `yaml:"template"`
+
+	Templates []Template `yaml:"templates"`
+
+	// Job specific properties that override global properties.
+	// Non-raw field is populated by the validator.
+	PropertiesRaw map[interface{}]interface{} `yaml:"properties"`
+	Properties    Properties
+
+	NetworkAssociations []NetworkAssociation `yaml:"networks"`
+}
+
+type Template struct {
+	Name        string `yaml:"name"`
+	ReleaseName string `yaml:"release"`
+}
+
+type Properties map[string]interface{}
+
+type Update struct {
+	// Integer pointers to determine absence
+	Canaries    *int `yaml:"canaries"`
+	MaxInFlight *int `yaml:"max_in_flight"`
+
+	// String pointers to determine absence
+	CanaryWatchTimeRaw *string `yaml:"canary_watch_time"`
+	UpdateWatchTimeRaw *string `yaml:"update_watch_time"`
+
+	// Populated by the validator
+	CanaryWatchTime *WatchTime
+	UpdateWatchTime *WatchTime
+}
+
+type NetworkAssociation struct {
+	NetworkName string `yaml:"name"`
+
+	// Non-raw field populated by the validator.
+	StaticIPsRaw []string `yaml:"static_ips"`
+	StaticIPs    []gonet.IP
+}
+
+// NewManifestFromPath returns manifest read from the file system.
+// Before returning manifest is syntactically validated.
+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.
+// Before returning manifest is syntactically validated.
+func NewManifestFromBytes(bytes []byte) (Manifest, error) {
+	var manifest Manifest
+	var deployment Deployment
+
+	err := candiedyaml.Unmarshal(bytes, &deployment)
+	if err != nil {
+		return manifest, bosherr.WrapError(err, "Parsing deployment")
+	}
+
+	manifest.Deployment = deployment
+
+	err = NewSyntaxValidator(&manifest).Validate()
+	if err != nil {
+		return manifest, bosherr.WrapError(err, "Validating manifest syntactically")
+	}
+
+	return manifest, nil
+}

data/go/src/boshprovisioner/deployment/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/deployment/manifest/manifest_test.go

@@ -0,0 +1,86 @@
+package manifest_test
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+
+	. "boshprovisioner/deployment/manifest"
+)
+
+var _ = Describe("Manifest", func() {
+	Describe("NewManifestFromBytes", func() {
+		It("returns manifest with deployment properties that have string keys", func() {
+			manifestBytes := []byte(`
+name: fake-deployment
+
+networks:
+- name: net1
+  type: dynamic
+
+compilation:
+  network: net1
+
+properties:
+  prop:
+    nest-prop: instance-val
+  props:
+  - name: nest-prop
+`)
+
+			manifest, err := NewManifestFromBytes(manifestBytes)
+			Expect(err).ToNot(HaveOccurred())
+
+			depProps := manifest.Deployment.Properties
+
+			// candiedyaml unmarshals manifest to map[interface{}]interface{}
+			// (encoding/json unmarshals manifest to map[string]interface{})
+			Expect(depProps).To(Equal(Properties(
+				map[string]interface{}{
+					"prop": map[string]interface{}{
+						"nest-prop": "instance-val",
+					},
+					"props": []interface{}{
+						map[string]interface{}{"name": "nest-prop"},
+					},
+				},
+			)))
+		})
+
+		It("returns manifest with job properties that have string keys", func() {
+			manifestBytes := []byte(`
+name: fake-deployment
+
+networks:
+- name: net1
+  type: dynamic
+
+compilation:
+  network: net1
+
+jobs:
+- name: job-1
+  properties:
+    prop:
+      nest-prop: instance-val
+    props:
+    - name: nest-prop
+`)
+
+			manifest, err := NewManifestFromBytes(manifestBytes)
+			Expect(err).ToNot(HaveOccurred())
+
+			jobProps := manifest.Deployment.Jobs[0].Properties
+
+			Expect(jobProps).To(Equal(Properties(
+				map[string]interface{}{
+					"prop": map[string]interface{}{
+						"nest-prop": "instance-val",
+					},
+					"props": []interface{}{
+						map[string]interface{}{"name": "nest-prop"},
+					},
+				},
+			)))
+		})
+	})
+})

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

@@ -0,0 +1,186 @@
+package manifest
+
+import (
+	bosherr "bosh/errors"
+
+	bputil "boshprovisioner/util"
+)
+
+// SyntaxValidator parses and saves all manifest values to determine
+// their syntactic validity. Determining if individual values make sense
+// in a greater context (within a deployment or a job) is outside of scope.
+// e.g. - can watch time string value be parsed into a time range?
+type SyntaxValidator struct {
+	deployment *Deployment
+}
+
+func NewSyntaxValidator(manifest *Manifest) SyntaxValidator {
+	if manifest == nil {
+		panic("Expected manifest to not be nil")
+	}
+
+	return SyntaxValidator{deployment: &manifest.Deployment}
+}
+
+func (v SyntaxValidator) Validate() error {
+	if v.deployment.Name == "" {
+		return bosherr.New("Missing deployment name")
+	}
+
+	err := v.validateUpdate(&v.deployment.Update)
+	if err != nil {
+		return bosherr.WrapError(err, "Deployment update")
+	}
+
+	for i, net := range v.deployment.Networks {
+		err := v.validateNetwork(&v.deployment.Networks[i])
+		if err != nil {
+			return bosherr.WrapError(err, "Network %s (%d)", net.Name, i)
+		}
+	}
+
+	for i, release := range v.deployment.Releases {
+		err := v.validateRelease(&v.deployment.Releases[i])
+		if err != nil {
+			return bosherr.WrapError(err, "Release %s (%d)", release.Name, i)
+		}
+	}
+
+	err = v.validateCompilation(&v.deployment.Compilation)
+	if err != nil {
+		return bosherr.WrapError(err, "Compilation")
+	}
+
+	for i, job := range v.deployment.Jobs {
+		err := v.validateJob(&v.deployment.Jobs[i])
+		if err != nil {
+			return bosherr.WrapError(err, "Job %s (%d)", job.Name, i)
+		}
+	}
+
+	props, err := bputil.NewStringKeyed().ConvertMap(v.deployment.PropertiesRaw)
+	if err != nil {
+		return bosherr.WrapError(err, "Deployment properties")
+	}
+
+	v.deployment.Properties = props
+
+	return nil
+}
+
+func (v SyntaxValidator) validateNetwork(network *Network) error {
+	if network.Name == "" {
+		return bosherr.New("Missing network name")
+	}
+
+	return v.validateNetworkType(network.Type)
+}
+
+func (v SyntaxValidator) validateNetworkType(networkType string) error {
+	if networkType == "" {
+		return bosherr.New("Missing network type")
+	}
+
+	for _, t := range NetworkTypes {
+		if networkType == t {
+			return nil
+		}
+	}
+
+	return bosherr.New("Unknown network type %s", networkType)
+}
+
+func (v SyntaxValidator) validateRelease(release *Release) error {
+	if release.Name == "" {
+		return bosherr.New("Missing release name")
+	}
+
+	if release.Version == "" {
+		return bosherr.New("Missing release version")
+	}
+
+	if release.URL == "" {
+		return bosherr.New("Missing release URL")
+	}
+
+	return nil
+}
+
+func (v SyntaxValidator) validateCompilation(compilation *Compilation) error {
+	if compilation.NetworkName == "" {
+		return bosherr.New("Missing network name")
+	}
+
+	return nil
+}
+
+func (v SyntaxValidator) validateJob(job *Job) error {
+	if job.Name == "" {
+		return bosherr.New("Missing job name")
+	}
+
+	if job.Template != nil {
+		return bosherr.New("'template' is deprecated in favor of 'templates'")
+	}
+
+	err := v.validateUpdate(&job.Update)
+	if err != nil {
+		return bosherr.WrapError(err, "Update")
+	}
+
+	props, err := bputil.NewStringKeyed().ConvertMap(job.PropertiesRaw)
+	if err != nil {
+		return bosherr.WrapError(err, "Properties")
+	}
+
+	job.Properties = props
+
+	for i, na := range job.NetworkAssociations {
+		err := v.validateNetworkAssociation(&job.NetworkAssociations[i])
+		if err != nil {
+			return bosherr.WrapError(err, "Network association %s (%d)", na.NetworkName, i)
+		}
+	}
+
+	return nil
+}
+
+// validateUpdate validates deployment level or job level update section
+func (v SyntaxValidator) validateUpdate(update *Update) error {
+	if update.CanaryWatchTimeRaw != nil {
+		watchTime, err := NewWatchTimeFromString(*update.CanaryWatchTimeRaw)
+		if err != nil {
+			return bosherr.WrapError(err, "Canary watch time")
+		}
+
+		update.CanaryWatchTime = &watchTime
+	}
+
+	if update.UpdateWatchTimeRaw != nil {
+		watchTime, err := NewWatchTimeFromString(*update.UpdateWatchTimeRaw)
+		if err != nil {
+			return bosherr.WrapError(err, "Update watch time")
+		}
+
+		update.UpdateWatchTime = &watchTime
+	}
+
+	return nil
+}
+
+func (v SyntaxValidator) validateNetworkAssociation(na *NetworkAssociation) error {
+	if na.NetworkName == "" {
+		return bosherr.New("Missing network name")
+	}
+
+	if na.StaticIPsRaw != nil {
+		ips, err := NewIPsFromStrings(na.StaticIPsRaw)
+		if err != nil {
+			return bosherr.WrapError(err, "Static IPs")
+		}
+
+		na.StaticIPs = ips
+	}
+
+	return nil
+}

data/go/src/boshprovisioner/deployment/manifest/watch_time.go

@@ -0,0 +1,47 @@
+package manifest
+
+import (
+	"strconv"
+	"strings"
+
+	bosherr "bosh/errors"
+)
+
+type WatchTime [2]int
+
+var (
+	DefaultWatchTime = WatchTime{0, 0}
+)
+
+func NewWatchTimeFromString(str string) (WatchTime, error) {
+	var watchTime WatchTime
+
+	parts := strings.Split(str, "-")
+	if len(parts) != 2 {
+		return watchTime, bosherr.New("Invalid watch time range %s", str)
+	}
+
+	min, err := strconv.Atoi(strings.Trim(parts[0], " "))
+	if err != nil {
+		return watchTime, bosherr.WrapError(
+			err, "Non-positive number as watch time minimum %s", parts[0])
+	}
+
+	max, err := strconv.Atoi(strings.Trim(parts[1], " "))
+	if err != nil {
+		return watchTime, bosherr.WrapError(
+			err, "Non-positive number as watch time maximum %s", parts[1])
+	}
+
+	if max < min {
+		return watchTime, bosherr.New(
+			"Watch time must have maximum greater than or equal minimum %s", str)
+	}
+
+	watchTime[0], watchTime[1] = min, max
+
+	return watchTime, nil
+}
+
+func (wt WatchTime) Start() int { return wt[0] }
+func (wt WatchTime) End() int   { return wt[1] }

data/go/src/boshprovisioner/deployment/manifest_reader.go

@@ -0,0 +1,46 @@
+package deployment
+
+import (
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+
+	bpdepman "boshprovisioner/deployment/manifest"
+)
+
+type ManifestReader struct {
+	path   string
+	fs     boshsys.FileSystem
+	logger boshlog.Logger
+}
+
+func NewManifestReader(
+	path string,
+	fs boshsys.FileSystem,
+	logger boshlog.Logger,
+) ManifestReader {
+	return ManifestReader{path: path, fs: fs, logger: logger}
+}
+
+func (r ManifestReader) Read() (Deployment, error) {
+	var deployment Deployment
+
+	manifest, err := bpdepman.NewManifestFromPath(r.path, r.fs)
+	if err != nil {
+		return deployment, bosherr.WrapError(err, "Reading manifest")
+	}
+
+	deployment.populateFromManifest(manifest)
+
+	// todo pass by ref?
+	err = NewSemanticValidator(deployment).Validate()
+	if err != nil {
+		return deployment, bosherr.WrapError(err, "Validating deployment semantically")
+	}
+
+	return deployment, nil
+}
+
+func (r ManifestReader) Close() error {
+	return nil
+}

data/go/src/boshprovisioner/deployment/reader_factory.go

@@ -0,0 +1,25 @@
+package deployment
+
+import (
+	boshlog "bosh/logger"
+	boshsys "bosh/system"
+)
+
+type ReaderFactory struct {
+	fs     boshsys.FileSystem
+	logger boshlog.Logger
+}
+
+func NewReaderFactory(
+	fs boshsys.FileSystem,
+	logger boshlog.Logger,
+) ReaderFactory {
+	return ReaderFactory{
+		fs:     fs,
+		logger: logger,
+	}
+}
+
+func (rf ReaderFactory) NewManifestReader(path string) ManifestReader {
+	return NewManifestReader(path, rf.fs, rf.logger)
+}