vagrant-bosh 0.0.6 → 0.0.7

data/go/src/boshprovisioner/agent/client/http_client_envelope.go

@@ -1,107 +0,0 @@
-package client
-
-import (
-	"encoding/json"
-
-	boshaction "bosh/agent/action"
-	bosherr "bosh/errors"
-)
-
-type requestEnvelope struct {
-	Method    reqMethod `json:"method"`
-	Arguments reqArgs   `json:"arguments"`
-	ReplyTo   string    `json:"reply_to"`
-}
-
-type reqMethod string
-type reqArgs []interface{}
-
-type responseEnvelope struct {
-	Value     json.RawMessage `json:"value"`
-	Exception respException   `json:"exception"`
-}
-
-type respException struct {
-	Message string `json:"message"`
-}
-
-type errandResultEnvelope struct {
-	Result boshaction.ErrandResult `json:"result"`
-}
-
-type compiledPackageEnvelope struct {
-	Result CompiledPackage `json:"result"`
-}
-
-func (re responseEnvelope) HasException() bool {
-	return len(re.Exception.Message) > 0
-}
-
-func (re responseEnvelope) StringValue() (string, error) {
-	value, err := re.interfaceValue()
-	if err != nil {
-		return "", err
-	}
-
-	str, ok := value.(string)
-	if !ok {
-		return "", bosherr.WrapError(err, "Converting value to string")
-	}
-
-	return str, nil
-}
-
-func (re responseEnvelope) MapValue() (map[string]interface{}, error) {
-	var m map[string]interface{}
-
-	value, err := re.interfaceValue()
-	if err != nil {
-		return m, err
-	}
-
-	m, ok := value.(map[string]interface{})
-	if !ok {
-		return m, bosherr.WrapError(err, "Converting value to map[string]interface{}")
-	}
-
-	return m, nil
-}
-
-func (re responseEnvelope) CustomValue(value interface{}) error {
-	return json.Unmarshal(re.Value, &value)
-}
-
-func (re responseEnvelope) TaskID() (string, bool) {
-	value, err := re.interfaceValue()
-	if err != nil {
-		return "", false
-	}
-
-	// Check if it looks like a task status
-	result, ok := value.(map[string]interface{})
-	if !ok {
-		return "", false
-	}
-
-	taskID, found := result["agent_task_id"]
-	if !found {
-		return "", false
-	}
-
-	if result["state"] != "running" {
-		return "", false
-	}
-
-	return taskID.(string), true
-}
-
-func (re responseEnvelope) interfaceValue() (interface{}, error) {
-	var value interface{}
-
-	err := json.Unmarshal(re.Value, &value)
-	if err != nil {
-		return value, err
-	}
-
-	return value, nil
-}

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

@@ -1,221 +0,0 @@
-package deployment
-
-import (
-	gonet "net"
-
-	boshaction "bosh/agent/action"
-
-	bpdepman "boshprovisioner/deployment/manifest"
-)
-
-type Deployment struct {
-	Manifest bpdepman.Manifest
-
-	Name string
-
-	Releases []Release
-
-	Networks []Network
-
-	Jobs []Job
-
-	CompilationInstance Instance
-}
-
-type Release struct {
-	Name    string
-	Version string
-
-	// Not offical BOSH manifest construct
-	URL string
-}
-
-const (
-	NetworkTypeManual  = bpdepman.NetworkTypeManual
-	NetworkTypeDynamic = bpdepman.NetworkTypeDynamic
-	NetworkTypeVip     = bpdepman.NetworkTypeVip
-)
-
-var NetworkTypes = []string{NetworkTypeManual, NetworkTypeDynamic, NetworkTypeVip}
-
-type Network struct {
-	Name string
-	Type string
-}
-
-type Job struct {
-	Name string
-
-	Templates []Template
-
-	Instances []Instance
-}
-
-type Template struct {
-	Name string
-
-	Release *Release
-}
-
-type Instance struct {
-	Index int
-
-	// Denormalized values to avoid passing dep/job/instance tuple
-	JobName        string
-	DeploymentName string
-
-	// Watch time will vary depending if an instance is a canary
-	WatchTime bpdepman.WatchTime
-
-	Properties Properties
-
-	NetworkAssociations []NetworkAssociation
-
-	// Represents current state of an associated VM
-	CurrentState boshaction.GetStateV1ApplySpec
-}
-
-type Properties map[string]interface{}
-
-type NetworkAssociation struct {
-	Network *Network
-
-	StaticIP gonet.IP
-
-	// StaticIP might equal to nil, though that does not indicate
-	// that this instance does not need a static IP
-	MustHaveStaticIP bool
-}
-
-// populateFromManifest populates deployment information
-// interpreted from deployment manifest.
-func (d *Deployment) populateFromManifest(manifest bpdepman.Manifest) {
-	d.populateNetworks(manifest)
-	d.populateReleases(manifest)
-	d.populateCompilationInstances(manifest)
-	d.populateJobs(manifest)
-	d.Manifest = manifest
-}
-
-func (d *Deployment) populateNetworks(manifest bpdepman.Manifest) {
-	for _, manNet := range manifest.Deployment.Networks {
-		d.Networks = append(d.Networks, Network{
-			Name: manNet.Name,
-			Type: manNet.Type,
-		})
-	}
-}
-
-func (d *Deployment) populateReleases(manifest bpdepman.Manifest) {
-	for _, manRelease := range manifest.Deployment.Releases {
-		d.Releases = append(d.Releases, Release{
-			Name:    manRelease.Name,
-			Version: manRelease.Version,
-			URL:     manRelease.URL,
-		})
-	}
-}
-
-func (d *Deployment) populateCompilationInstances(manifest bpdepman.Manifest) {
-	network := d.findNetworkOrDefault(manifest.Deployment.Compilation.NetworkName)
-
-	d.CompilationInstance = Instance{
-		Index: 0,
-
-		JobName:        "compilation",
-		DeploymentName: manifest.Deployment.Name,
-
-		NetworkAssociations: []NetworkAssociation{
-			NetworkAssociation{Network: network},
-		},
-	}
-}
-
-func (d *Deployment) populateJobs(manifest bpdepman.Manifest) {
-	for _, manJob := range manifest.Deployment.Jobs {
-		d.Jobs = append(d.Jobs, d.buildJob(manifest.Deployment, manJob))
-	}
-}
-
-func (d *Deployment) buildJob(manDep bpdepman.Deployment, manJob bpdepman.Job) Job {
-	job := Job{Name: manJob.Name}
-
-	for i := 0; i < manJob.Instances; i++ {
-		watchTime := manDep.InstanceWatchTime(manJob, i)
-		properties := manDep.InstanceProperties(manJob, i)
-		netAssocs := d.buildNetworkAssociations(manJob, i)
-
-		job.Instances = append(job.Instances, Instance{
-			Index: i,
-
-			JobName:        manJob.Name,
-			DeploymentName: manDep.Name,
-
-			WatchTime:  watchTime,
-			Properties: Properties(properties),
-
-			NetworkAssociations: netAssocs,
-		})
-	}
-
-	// todo check to make sure release is present
-	for _, manTemplate := range manJob.Templates {
-		release := d.findReleaseOrDefault(manTemplate.ReleaseName)
-
-		job.Templates = append(job.Templates, Template{
-			Name:    manTemplate.Name,
-			Release: release,
-		})
-	}
-
-	return job
-}
-
-func (d *Deployment) buildNetworkAssociations(manJob bpdepman.Job, i int) []NetworkAssociation {
-	var netAssocs []NetworkAssociation
-
-	for _, manNa := range manJob.NetworkAssociations {
-		var staticIP gonet.IP
-
-		network := d.findNetworkOrDefault(manNa.NetworkName)
-
-		if i < len(manNa.StaticIPs) {
-			staticIP = manNa.StaticIPs[i]
-		}
-
-		netAssocs = append(netAssocs, NetworkAssociation{
-			Network:  network,
-			StaticIP: staticIP,
-
-			MustHaveStaticIP: len(manNa.StaticIPs) > 0,
-		})
-	}
-
-	return netAssocs
-}
-
-func (d *Deployment) findReleaseOrDefault(name string) *Release {
-	// todo check against empty release name
-	for _, release := range d.Releases {
-		if release.Name == name {
-			return &release
-		}
-	}
-
-	// Assume if there is only one release it's default
-	if len(d.Releases) == 1 {
-		return &d.Releases[0]
-	}
-
-	return nil
-}
-
-func (d *Deployment) findNetworkOrDefault(name string) *Network {
-	for _, net := range d.Networks {
-		if net.Name == name {
-			return &net
-		}
-	}
-
-	return nil
-}

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

@@ -1,54 +0,0 @@
-package deployment
-
-import (
-	"fmt"
-)
-
-type NetworkConfiguration struct {
-	IP      string
-	Netmask string
-	Gateway string
-}
-
-func (i Instance) NetworkConfigurationForNetworkAssociation(na NetworkAssociation) NetworkConfiguration {
-	// If instance is always has static ip assigned there is nothing to resolve
-	if na.MustHaveStaticIP {
-		return NetworkConfiguration{IP: na.StaticIP.String()}
-	}
-
-	// Dynamic network information can be resolved after VM is powered on.
-	if na.Network.Type == NetworkTypeDynamic {
-		networkSpec, ok := i.CurrentState.NetworkSpecs[na.Network.Name]
-		if !ok {
-			return NetworkConfiguration{}
-		}
-
-		// todo better way to deserialize? structmap?
-		ipStr, ok := networkSpec.Fields["ip"].(string)
-		if !ok {
-			return NetworkConfiguration{}
-		}
-
-		netmaskStr, ok := networkSpec.Fields["netmask"].(string)
-		if !ok {
-			return NetworkConfiguration{}
-		}
-
-		gatewayStr, ok := networkSpec.Fields["gateway"].(string)
-		if !ok {
-			return NetworkConfiguration{}
-		}
-
-		return NetworkConfiguration{
-			IP:      ipStr,
-			Netmask: netmaskStr,
-			Gateway: gatewayStr,
-		}
-	}
-
-	return NetworkConfiguration{}
-}
-
-func (i Instance) DNDRecordName(na NetworkAssociation) string {
-	return fmt.Sprintf("%d.%s.%s.%s.bosh", i.Index, i.JobName, na.Network.Name, i.DeploymentName)
-}

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

@@ -1,84 +0,0 @@
-package manifest
-
-import (
-	"encoding/json"
-
-	bosherr "bosh/errors"
-)
-
-var (
-	DefaultWatchTime = WatchTime{0, 60000}
-)
-
-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.UpdateWatchTime(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
-}