vagrant-bosh 0.0.6 → 0.0.7

data/go/bin/env

@@ -1,13 +0,0 @@
-#!/bin/bash 
-
-set -e
-
-base=$( cd "$( dirname "$( dirname "$0" )")" && pwd )
-
-go_agent_base=$( cd "$( dirname "$base" )" && cd bosh/go_agent && pwd )
-
-export GOPATH=$base:$go_agent_base
-export GOBIN=$base/gobin
-export PATH=$PATH:$base/gobin
-
-exec $@

data/go/bin/go

@@ -1,5 +0,0 @@
-#!/bin/bash 
-
-set -e
-
-exec $(dirname $0)/env go $@

data/go/bin/golint

@@ -1,19 +0,0 @@
-#!/bin/bash 
-
-BINDIR=$(dirname $0)
-BASEDIR=$(dirname $BINDIR)
-
-$BINDIR/go install github.com/golang/lint/golint
-
-export PATH=$PATH:$($BINDIR/go env GOBIN)
-
-errors=$(
-  golint $BASEDIR/src/boshprovisioner                           \
-    | grep -v -e 'should have comment.* or be unexported'   \
-    | grep -v    'error strings should not be capitalized'
-)
-
-if [ "$(echo -n "$errors")" != "" ]; then
-  echo "$errors"
-  exit 1
-fi

data/go/bin/test

@@ -1,37 +0,0 @@
-#!/bin/bash
-
-result=0
-
-bin=$(dirname $0)
-
-echo -e "\n Formatting packages..."
-$bin/go fmt boshprovisioner/...
-let "result+=$?"
-
-echo -e "\n Installing ginkgo..."
-$bin/go install github.com/onsi/ginkgo/ginkgo
-let "result+=$?"
-
-echo -e "\n Testing packages..."
-$bin/env ginkgo -r $bin/../src/boshprovisioner
-let "result+=$?"
-
-echo -e "\n Vetting packages for potential issues..."
-$bin/go vet boshprovisioner/...
-let "result+=$?"
-
-echo -e "\n Checking with golint..."
-$bin/golint
-let "result+=$?"
-
-echo -e "\n Running build script to confirm everything compiles..."
-$bin/build-linux-amd64
-let "result+=$?"
-
-if [ $result -eq 0 ]; then
-	echo -e "\nSUITE SUCCESS"
-else
-	echo -e "\nSUITE FAILURE"
-fi
-
-exit $result

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

@@ -1,73 +0,0 @@
-package client
-
-import (
-	boshaction "bosh/agent/action"
-	boshas "bosh/agent/applier/applyspec"
-	boshcomp "bosh/agent/compiler"
-)
-
-type Client interface {
-	TaskManager
-	VMAdministrator
-	StateManager
-	JobManager
-	PackageCompiler
-	DiskManager
-	NetworkManager
-}
-
-type TaskManager interface {
-	Ping() (string, error)
-	GetTask(string) (interface{}, error)
-	CancelTask(string) (string, error)
-}
-
-// VMAdministrator provides administrative API for the agent
-// todo eliminate remaining param names
-type VMAdministrator interface {
-	SSH(cmd string, params boshaction.SshParams) (map[string]interface{}, error)
-	FetchLogs(logType string, filters []string) (map[string]interface{}, error)
-}
-
-type StateManager interface {
-	Prepare(boshas.V1ApplySpec) (string, error)
-	Apply(boshas.V1ApplySpec) (string, error)
-	GetState(filters ...string) (boshaction.GetStateV1ApplySpec, error)
-}
-
-type JobManager interface {
-	Start() (string, error)
-	Stop() (string, error)
-	Drain(boshaction.DrainType, ...boshas.V1ApplySpec) (int, error)
-	RunErrand() (boshaction.ErrandResult, error)
-}
-
-// CompiledPackage keeps information about compiled package asset
-// todo move into agent
-type CompiledPackage struct {
-	BlobID string `json:"blobstore_id"`
-	SHA1   string `json:"sha1"`
-}
-
-type PackageCompiler interface {
-	CompilePackage(
-		blobID string,
-		sha1 string,
-		name string,
-		version string,
-		deps boshcomp.Dependencies,
-	) (CompiledPackage, error)
-}
-
-type DiskManager interface {
-	// ListDisk(...)
-	// MigrateDisk(...)
-	// MountDisk(...)
-	// UnmountDisk(...)
-}
-
-type NetworkManager interface {
-	// PrepareNetworkChange(...)
-	// PrepareConfigureNetworks(...)
-	// ConfigureNetworks(...)
-}

data/go/src/boshprovisioner/agent/client/fakes/fake_client.go

@@ -1,81 +0,0 @@
-package fakes
-
-import (
-	boshaction "bosh/agent/action"
-	boshas "bosh/agent/applier/applyspec"
-	boshcomp "bosh/agent/compiler"
-	bosherr "bosh/errors"
-
-	bpagclient "boshprovisioner/agent/client"
-)
-
-type FakeClient struct {
-	GetStateState  boshaction.GetStateV1ApplySpec
-	GetStateStates []boshaction.GetStateV1ApplySpec
-	GetStateErr    error
-}
-
-func (c *FakeClient) Ping() (string, error) {
-	return "", bosherr.New("fake-ping-err")
-}
-
-func (c *FakeClient) GetTask(string) (interface{}, error) {
-	return "", bosherr.New("fake-get-task-err")
-}
-
-func (c *FakeClient) CancelTask(string) (string, error) {
-	return "", bosherr.New("fake-cancel-task-err")
-}
-
-func (c *FakeClient) SSH(cmd string, params boshaction.SshParams) (map[string]interface{}, error) {
-	return nil, bosherr.New("fake-ssh-err")
-}
-
-func (c *FakeClient) FetchLogs(logType string, filters []string) (map[string]interface{}, error) {
-	return nil, bosherr.New("fake-fetch-logs-err")
-}
-
-func (c *FakeClient) Prepare(boshas.V1ApplySpec) (string, error) {
-	return "", bosherr.New("fake-prepare-err")
-}
-
-func (c *FakeClient) Apply(boshas.V1ApplySpec) (string, error) {
-	return "", bosherr.New("fake-apply-err")
-}
-
-func (c *FakeClient) GetState(filters ...string) (boshaction.GetStateV1ApplySpec, error) {
-	state := c.GetStateState
-
-	if c.GetStateStates != nil {
-		state = c.GetStateStates[0]
-		c.GetStateStates = c.GetStateStates[1:]
-	}
-
-	return state, c.GetStateErr
-}
-
-func (c *FakeClient) Start() (string, error) {
-	return "", bosherr.New("fake-start-err")
-}
-
-func (c *FakeClient) Stop() (string, error) {
-	return "", bosherr.New("fake-stop-err")
-}
-
-func (c *FakeClient) Drain(boshaction.DrainType, ...boshas.V1ApplySpec) (int, error) {
-	return 0, bosherr.New("fake-drain-err")
-}
-
-func (c *FakeClient) RunErrand() (boshaction.ErrandResult, error) {
-	return boshaction.ErrandResult{}, bosherr.New("fake-run-errand-err")
-}
-
-func (c *FakeClient) CompilePackage(
-	blobID string,
-	sha1 string,
-	name string,
-	version string,
-	deps boshcomp.Dependencies,
-) (bpagclient.CompiledPackage, error) {
-	return bpagclient.CompiledPackage{}, bosherr.New("fake-ping-err")
-}

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

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