vagrant-bosh 0.0.1

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

@@ -0,0 +1,299 @@
+package client
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	boshaction "bosh/agent/action"
+	boshas "bosh/agent/applier/applyspec"
+	boshcomp "bosh/agent/compiler"
+	bosherr "bosh/errors"
+	boshlog "bosh/logger"
+)
+
+const httpClientLogTag = "HTTPClient"
+
+type HTTPRequester interface {
+	Do(*http.Request) (*http.Response, error)
+}
+
+type HTTPClient struct {
+	url       *url.URL
+	requester HTTPRequester
+	logger    boshlog.Logger
+
+	// Alias to method calls for convenience
+	quickRequest requestFunc
+	longRequest  requestFunc
+}
+
+type requestFunc func(reqMethod, reqArgs) (responseEnvelope, error)
+
+func NewInsecureHTTPClientWithURI(uri string, logger boshlog.Logger) (HTTPClient, error) {
+	mTLSConfig := &tls.Config{InsecureSkipVerify: true}
+	transport := &http.Transport{TLSClientConfig: mTLSConfig}
+	httpRequester := &http.Client{Transport: transport}
+	return NewHTTPClientWithURI(uri, httpRequester, logger)
+}
+
+func NewHTTPClientWithURI(uri string, requester HTTPRequester, logger boshlog.Logger) (HTTPClient, error) {
+	url, err := url.ParseRequestURI(uri)
+	if err != nil {
+		return HTTPClient{}, bosherr.WrapError(err, "Parsing request uri")
+	}
+
+	return NewHTTPClient(url, requester, logger), nil
+}
+
+func NewHTTPClient(url *url.URL, requester HTTPRequester, logger boshlog.Logger) HTTPClient {
+	client := HTTPClient{
+		url:       url,
+		requester: requester,
+		logger:    logger,
+	}
+
+	client.quickRequest = client.makeQuickRequest
+	client.longRequest = client.makeLongRequest
+
+	return client
+}
+
+func (ac HTTPClient) Ping() (string, error) {
+	return ac.makeStringRequest(ac.quickRequest, "ping", reqArgs{})
+}
+
+func (ac HTTPClient) GetTask(taskID string) (interface{}, error) {
+	val, err := ac.makeQuickRequest("get_task", reqArgs{taskID})
+	if err != nil {
+		return nil, bosherr.WrapError(err, "makeRequest")
+	}
+
+	return val.MapValue()
+}
+
+func (ac HTTPClient) CancelTask(taskID string) (string, error) {
+	return ac.makeStringRequest(ac.quickRequest, "cancel_task", reqArgs{taskID})
+}
+
+func (ac HTTPClient) SSH(cmd string, params boshaction.SshParams) (map[string]interface{}, error) {
+	val, err := ac.makeQuickRequest("ssh", reqArgs{cmd, params})
+	if err != nil {
+		return nil, bosherr.WrapError(err, "makeRequest")
+	}
+
+	return val.MapValue()
+}
+
+func (ac HTTPClient) FetchLogs(logType string, filters []string) (map[string]interface{}, error) {
+	val, err := ac.makeLongRequest("fetch_logs", reqArgs{logType, filters})
+	if err != nil {
+		return nil, bosherr.WrapError(err, "makeRequest")
+	}
+
+	return val.MapValue()
+}
+
+func (ac HTTPClient) Prepare(desiredSpec boshas.V1ApplySpec) (string, error) {
+	return ac.makeStringRequest(ac.longRequest, "prepare", reqArgs{desiredSpec})
+}
+
+func (ac HTTPClient) Apply(desiredSpec boshas.V1ApplySpec) (string, error) {
+	return ac.makeStringRequest(ac.longRequest, "apply", reqArgs{desiredSpec})
+}
+
+func (ac HTTPClient) Start() (string, error) {
+	return ac.makeStringRequest(ac.quickRequest, "start", reqArgs{})
+}
+
+func (ac HTTPClient) Stop() (string, error) {
+	return ac.makeStringRequest(ac.longRequest, "stop", reqArgs{})
+}
+
+func (ac HTTPClient) Drain(drainType boshaction.DrainType, newSpecs ...boshas.V1ApplySpec) (int, error) {
+	var result int
+
+	args := reqArgs{drainType}
+
+	for _, newSpec := range newSpecs {
+		args = append(args, newSpec)
+	}
+
+	val, err := ac.makeLongRequest("drain", args)
+	if err != nil {
+		return result, bosherr.WrapError(err, "makeRequest")
+	}
+
+	err = val.CustomValue(&result)
+	if err != nil {
+		return result, bosherr.WrapError(err, "Converting response to int")
+	}
+
+	return result, nil
+}
+
+func (ac HTTPClient) GetState(filters ...string) (boshaction.GetStateV1ApplySpec, error) {
+	var result boshaction.GetStateV1ApplySpec
+
+	args := reqArgs{}
+
+	for _, filter := range filters {
+		args = append(args, filter)
+	}
+
+	val, err := ac.makeQuickRequest("get_state", args)
+	if err != nil {
+		return result, bosherr.WrapError(err, "makeRequest")
+	}
+
+	err = val.CustomValue(&result)
+	if err != nil {
+		return result, bosherr.WrapError(err, "Converting response to apply spec")
+	}
+
+	return result, nil
+}
+
+func (ac HTTPClient) RunErrand() (boshaction.ErrandResult, error) {
+	var result errandResultEnvelope
+
+	val, err := ac.makeLongRequest("run_errand", reqArgs{})
+	if err != nil {
+		return result.Result, bosherr.WrapError(err, "makeRequest")
+	}
+
+	err = val.CustomValue(&result)
+	if err != nil {
+		return result.Result, bosherr.WrapError(
+			err, "Converting response to errand result")
+	}
+
+	return result.Result, nil
+}
+
+func (ac HTTPClient) CompilePackage(blobID, sha1, name, version string, deps boshcomp.Dependencies) (CompiledPackage, error) {
+	var result compiledPackageEnvelope
+
+	val, err := ac.makeLongRequest(
+		"compile_package",
+		reqArgs{blobID, sha1, name, version, deps},
+	)
+	if err != nil {
+		return result.Result, bosherr.WrapError(err, "makeRequest")
+	}
+
+	err = val.CustomValue(&result)
+	if err != nil {
+		return result.Result, bosherr.WrapError(
+			err, "Converting response to errand result")
+	}
+
+	return result.Result, nil
+}
+
+func (ac HTTPClient) makeStringRequest(f requestFunc, method reqMethod, args reqArgs) (string, error) {
+	val, err := f(method, args)
+	if err != nil {
+		return "", bosherr.WrapError(err, "makeXRequest")
+	}
+
+	return val.StringValue()
+}
+
+func (ac HTTPClient) makeLongRequest(method reqMethod, args reqArgs) (responseEnvelope, error) {
+	val, err := ac.makeQuickRequest(method, args)
+	if err != nil {
+		return responseEnvelope{}, bosherr.WrapError(err, "makeRequest")
+	}
+
+	for {
+		taskID, found := val.TaskID()
+		if !found {
+			return val, nil
+		}
+
+		time.Sleep(1 * time.Second)
+
+		val, err = ac.makeQuickRequest("get_task", reqArgs{taskID})
+		if err != nil {
+			return responseEnvelope{}, bosherr.WrapError(err, "makeRequest")
+		}
+	}
+}
+
+func (ac HTTPClient) makeQuickRequest(method reqMethod, args reqArgs) (responseEnvelope, error) {
+	var responseBody responseEnvelope
+
+	requestBody := requestEnvelope{
+		Method:    method,
+		Arguments: args,
+		ReplyTo:   "n-a",
+	}
+
+	requestBytes, err := json.Marshal(requestBody)
+	if err != nil {
+		return responseBody, bosherr.WrapError(err, "Marshalling request body")
+	}
+
+	responseBytes, err := ac.makePlainRequest(string(requestBytes), "application/json")
+	if err != nil {
+		return responseBody, bosherr.WrapError(err, "Making plain request")
+	}
+
+	err = json.Unmarshal(responseBytes, &responseBody)
+	if err != nil {
+		return responseBody, bosherr.WrapError(err, "Unmarshalling response body")
+	}
+
+	if responseBody.HasException() {
+		return responseBody, bosherr.New("Ended with exception %#v", responseBody.Exception)
+	}
+
+	return responseBody, nil
+}
+
+func (ac HTTPClient) makePlainRequest(requestBody, contentType string) ([]byte, error) {
+	ac.logger.Debug(httpClientLogTag, "Making request url=%s", ac.url.String())
+
+	ac.logger.DebugWithDetails(httpClientLogTag, "Request body", requestBody)
+
+	request, err := http.NewRequest("POST", "", strings.NewReader(requestBody))
+	if err != nil {
+		return []byte{}, bosherr.WrapError(err, "Building request")
+	}
+
+	// Basic auth credentials are retrieved from the url
+	request.URL = ac.url
+
+	request.Header.Set("Content-Type", contentType)
+
+	response, err := ac.requester.Do(request)
+	if err != nil {
+		if response != nil {
+			ac.logger.Error(httpClientLogTag,
+				"Received error=%v (response=%d)", err, response.StatusCode)
+		} else {
+			ac.logger.Error(httpClientLogTag,
+				"Received error=%v (no response)", err)
+		}
+		return []byte{}, bosherr.WrapError(err, "Making request failed")
+	}
+
+	ac.logger.Debug(httpClientLogTag,
+		"Received response status=%d", response.StatusCode)
+
+	defer response.Body.Close()
+
+	responseBytes, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return nil, bosherr.WrapError(err, "Reading response body")
+	}
+
+	ac.logger.DebugWithDetails(httpClientLogTag, "Response body", responseBytes)
+
+	return responseBytes, nil
+}

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

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

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

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