vagrant-bosh 0.0.6 → 0.0.7

data/go/src/boshprovisioner/main/config.go

@@ -1,95 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-
-	bosherr "bosh/errors"
-	boshsys "bosh/system"
-
-	bpprov "boshprovisioner/provisioner"
-	bpvm "boshprovisioner/vm"
-)
-
-var DefaultWardenConfig = Config{
-	VMProvisioner: bpvm.VMProvisionerConfig{
-		AgentProvisioner: bpvm.AgentProvisionerConfig{
-			Infrastructure: "warden",
-			Platform:       "ubuntu",
-			Mbus:           "https://user:password@127.0.0.1:4321/agent",
-		},
-	},
-}
-
-var DefaultWardenAgentConfiguration = map[string]interface{}{
-	"Platform": map[string]interface{}{
-		"Linux": map[string]interface{}{
-			"UseDefaultTmpDir":              true,
-			"UsePreformattedPersistentDisk": true,
-			"BindMountPersistentDisk":       true,
-		},
-	},
-}
-
-type Config struct {
-	// Assets dir is used as a temporary location to transfer files from host to guest.
-	// It will not be created since assets already must be present.
-	AssetsDir string `json:"assets_dir"`
-
-	// Repos dir is mainly used to record what was placed in the blobstore.
-	// It will be created if it does not exist.
-	ReposDir string `json:"repos_dir"`
-
-	Blobstore bpprov.BlobstoreConfig `json:"blobstore"`
-
-	VMProvisioner bpvm.VMProvisionerConfig `json:"vm_provisioner"`
-
-	DeploymentProvisioner bpprov.DeploymentProvisionerConfig `json:"deployment_provisioner"`
-}
-
-func NewConfigFromPath(path string, fs boshsys.FileSystem) (Config, error) {
-	var config Config
-
-	bytes, err := fs.ReadFile(path)
-	if err != nil {
-		return config, bosherr.WrapError(err, "Reading config %s", path)
-	}
-
-	config = DefaultWardenConfig
-
-	err = json.Unmarshal(bytes, &config)
-	if err != nil {
-		return config, bosherr.WrapError(err, "Unmarshalling config")
-	}
-
-	if config.VMProvisioner.AgentProvisioner.Configuration == nil {
-		config.VMProvisioner.AgentProvisioner.Configuration = DefaultWardenAgentConfiguration
-	}
-
-	err = config.validate()
-	if err != nil {
-		return config, bosherr.WrapError(err, "Validating config")
-	}
-
-	return config, nil
-}
-
-func (c Config) validate() error {
-	if c.AssetsDir == "" {
-		return bosherr.New("Must provide non-empty assets_dir")
-	}
-
-	if c.ReposDir == "" {
-		return bosherr.New("Must provide non-empty repos_dir")
-	}
-
-	if c.Blobstore.Type != bpprov.BlobstoreConfigTypeLocal {
-		return bosherr.New("Blobstore type must be local")
-	}
-
-	err := c.Blobstore.Validate()
-	if err != nil {
-		return bosherr.WrapError(err, "Validating blobstore configuration")
-	}
-
-	return nil
-}

data/go/src/boshprovisioner/main/config_test.go

@@ -1,67 +0,0 @@
-package main_test
-
-import (
-	fakesys "bosh/system/fakes"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	. "boshprovisioner/main"
-	bpvm "boshprovisioner/vm"
-)
-
-var _ = Describe("NewConfigFromPath", func() {
-	var (
-		fs *fakesys.FakeFileSystem
-	)
-
-	BeforeEach(func() {
-		fs = fakesys.NewFakeFileSystem()
-	})
-
-	It("defautls null values to agent provisioner config defaults", func() {
-		configJSON := `{
-      "manifest_path": "fake-manifest-path",
-      "assets_dir": "fake-assets-dir",
-      "repos_dir": "fake-repos-dir",
-      "blobstore": {
-        "provider": "local",
-        "options": {
-          "blobstore_path": "fake-blobstore-path"
-        }
-      },
-      "vm_provisioner": {
-        "agent_provisioner": {
-          "infrastructure": null,
-          "platform": null,
-          "configuration": null,
-          "mbus": null
-        }
-      }
-    }`
-
-		err := fs.WriteFileString("/tmp/config", configJSON)
-		Expect(err).ToNot(HaveOccurred())
-
-		config, err := NewConfigFromPath("/tmp/config", fs)
-		Expect(err).ToNot(HaveOccurred())
-
-		Expect(config.VMProvisioner.AgentProvisioner).To(Equal(
-			bpvm.AgentProvisionerConfig{
-				Infrastructure: "warden",
-				Platform:       "ubuntu",
-
-				Configuration: map[string]interface{}{
-					"Platform": map[string]interface{}{
-						"Linux": map[string]interface{}{
-							"UseDefaultTmpDir":              true,
-							"UsePreformattedPersistentDisk": true,
-							"BindMountPersistentDisk":       true,
-						},
-					},
-				},
-
-				Mbus: "https://user:password@127.0.0.1:4321/agent",
-			},
-		))
-	})
-})

data/go/src/boshprovisioner/main/main.go

@@ -1,185 +0,0 @@
-package main
-
-import (
-	"flag"
-	"os"
-
-	boshblob "bosh/blobstore"
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-	boshuuid "bosh/uuid"
-
-	bpdep "boshprovisioner/deployment"
-	bpdload "boshprovisioner/downloader"
-	bpeventlog "boshprovisioner/eventlog"
-	bpinstance "boshprovisioner/instance"
-	bptplcomp "boshprovisioner/instance/templatescompiler"
-	bpinstupd "boshprovisioner/instance/updater"
-	bppkgscomp "boshprovisioner/packagescompiler"
-	bpprov "boshprovisioner/provisioner"
-	bprel "boshprovisioner/release"
-	bpreljob "boshprovisioner/release/job"
-	bptar "boshprovisioner/tar"
-	bpvagrantvm "boshprovisioner/vm/vagrant"
-)
-
-const mainLogTag = "main"
-
-var (
-	configPathOpt = flag.String("configPath", "", "Path to configuration file")
-)
-
-func main() {
-	logger, fs, runner, uuidGen := basicDeps()
-
-	defer logger.HandlePanic("Main")
-
-	flag.Parse()
-
-	config, err := NewConfigFromPath(*configPathOpt, fs)
-	if err != nil {
-		logger.Error(mainLogTag, "Loading config %s", err.Error())
-		os.Exit(1)
-	}
-
-	localBlobstore := boshblob.NewLocalBlobstore(
-		fs,
-		uuidGen,
-		config.Blobstore.Options,
-	)
-
-	blobstore := boshblob.NewSHA1VerifiableBlobstore(localBlobstore)
-
-	downloader := bpdload.NewDefaultMuxDownloader(blobstore, fs, logger)
-
-	extractor := bptar.NewCmdExtractor(runner, fs, logger)
-
-	compressor := bptar.NewCmdCompressor(runner, fs, logger)
-
-	renderedArchivesCompiler := bptplcomp.NewRenderedArchivesCompiler(
-		fs,
-		runner,
-		compressor,
-		logger,
-	)
-
-	jobReaderFactory := bpreljob.NewReaderFactory(
-		downloader,
-		extractor,
-		fs,
-		logger,
-	)
-
-	err = fs.MkdirAll(config.ReposDir, os.ModeDir)
-	if err != nil {
-		logger.Error(mainLogTag, "Failed to create repos dir: %s", err.Error())
-		os.Exit(1)
-	}
-
-	reposFactory := NewReposFactory(config.ReposDir, fs, downloader, blobstore, logger)
-
-	blobstoreProvisioner := bpprov.NewBlobstoreProvisioner(
-		fs,
-		config.Blobstore,
-		logger,
-	)
-
-	err = blobstoreProvisioner.Provision()
-	if err != nil {
-		logger.Error(mainLogTag, "Failed to provision blobstore: %s", err.Error())
-		os.Exit(1)
-	}
-
-	templatesCompiler := bptplcomp.NewConcreteTemplatesCompiler(
-		renderedArchivesCompiler,
-		jobReaderFactory,
-		reposFactory.NewJobsRepo(),
-		reposFactory.NewTemplateToJobRepo(),
-		reposFactory.NewRuntimePackagesRepo(),
-		reposFactory.NewTemplatesRepo(),
-		blobstore,
-		logger,
-	)
-
-	eventLog := bpeventlog.NewLog(logger)
-
-	packagesCompilerFactory := bppkgscomp.NewConcretePackagesCompilerFactory(
-		reposFactory.NewPackagesRepo(),
-		reposFactory.NewCompiledPackagesRepo(),
-		blobstore,
-		eventLog,
-		logger,
-	)
-
-	updaterFactory := bpinstupd.NewUpdaterFactory(
-		templatesCompiler,
-		packagesCompilerFactory,
-		eventLog,
-		logger,
-	)
-
-	releaseReaderFactory := bprel.NewReaderFactory(
-		downloader,
-		extractor,
-		fs,
-		logger,
-	)
-
-	deploymentReaderFactory := bpdep.NewReaderFactory(fs, logger)
-
-	vagrantVMProvisionerFactory := bpvagrantvm.NewVMProvisionerFactory(
-		fs,
-		runner,
-		config.AssetsDir,
-		config.Blobstore.AsMap(),
-		config.VMProvisioner,
-		eventLog,
-		logger,
-	)
-
-	vagrantVMProvisioner := vagrantVMProvisionerFactory.NewVMProvisioner()
-
-	releaseCompiler := bpprov.NewReleaseCompiler(
-		releaseReaderFactory,
-		packagesCompilerFactory,
-		templatesCompiler,
-		vagrantVMProvisioner,
-		eventLog,
-		logger,
-	)
-
-	instanceProvisioner := bpinstance.NewInstanceProvisioner(
-		updaterFactory,
-		logger,
-	)
-
-	singleVMProvisionerFactory := bpprov.NewSingleVMProvisionerFactory(
-		deploymentReaderFactory,
-		config.DeploymentProvisioner,
-		vagrantVMProvisioner,
-		releaseCompiler,
-		instanceProvisioner,
-		eventLog,
-		logger,
-	)
-
-	deploymentProvisioner := singleVMProvisionerFactory.NewSingleVMProvisioner()
-
-	err = deploymentProvisioner.Provision()
-	if err != nil {
-		logger.Error(mainLogTag, "Failed to provision deployment: %s", err.Error())
-		os.Exit(1)
-	}
-}
-
-func basicDeps() (boshlog.Logger, boshsys.FileSystem, boshsys.CmdRunner, boshuuid.Generator) {
-	logger := boshlog.NewWriterLogger(boshlog.LevelDebug, os.Stderr, os.Stderr)
-
-	fs := boshsys.NewOsFileSystem(logger)
-
-	runner := boshsys.NewExecCmdRunner(logger)
-
-	uuidGen := boshuuid.NewGenerator()
-
-	return logger, fs, runner, uuidGen
-}

data/go/src/boshprovisioner/main/main_suite_test.go

@@ -1,13 +0,0 @@
-package main_test
-
-import (
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"testing"
-)
-
-func TestMain(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Main Suite")
-}

data/go/src/boshprovisioner/main/repos_factory.go

@@ -1,86 +0,0 @@
-package main
-
-import (
-	"path/filepath"
-
-	boshblob "bosh/blobstore"
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-
-	bpdload "boshprovisioner/downloader"
-	bpindex "boshprovisioner/index"
-	bpjobsrepo "boshprovisioner/instance/templatescompiler/jobsrepo"
-	bptplsrepo "boshprovisioner/instance/templatescompiler/templatesrepo"
-	bpcpkgsrepo "boshprovisioner/packagescompiler/compiledpackagesrepo"
-	bppkgsrepo "boshprovisioner/packagescompiler/packagesrepo"
-)
-
-type ReposFactory struct {
-	dirPath    string
-	fs         boshsys.FileSystem
-	downloader bpdload.Downloader
-	blobstore  boshblob.Blobstore
-	logger     boshlog.Logger
-}
-
-func NewReposFactory(
-	dirPath string,
-	fs boshsys.FileSystem,
-	downloader bpdload.Downloader,
-	blobstore boshblob.Blobstore,
-	logger boshlog.Logger,
-) ReposFactory {
-	return ReposFactory{
-		dirPath:    dirPath,
-		fs:         fs,
-		downloader: downloader,
-		blobstore:  blobstore,
-		logger:     logger,
-	}
-}
-
-func (f ReposFactory) NewJobsRepo() bpjobsrepo.JobsRepository {
-	return bpjobsrepo.NewConcreteJobsRepository(
-		f.newIndex("jobs"),
-		f.logger,
-	)
-}
-
-func (f ReposFactory) NewTemplateToJobRepo() bpjobsrepo.TemplateToJobRepository {
-	return bpjobsrepo.NewConcreteTemplateToJobRepository(
-		f.newIndex("templates_to_job"),
-		f.logger,
-	)
-}
-
-func (f ReposFactory) NewRuntimePackagesRepo() bpjobsrepo.RuntimePackagesRepository {
-	return bpjobsrepo.NewConcreteRuntimePackagesRepository(
-		f.newIndex("runtime_packages"),
-		f.logger,
-	)
-}
-
-func (f ReposFactory) NewTemplatesRepo() bptplsrepo.TemplatesRepository {
-	return bptplsrepo.NewConcreteTemplatesRepository(
-		f.newIndex("templates"),
-		f.logger,
-	)
-}
-
-func (f ReposFactory) NewPackagesRepo() bppkgsrepo.PackagesRepository {
-	return bppkgsrepo.NewConcretePackagesRepository(
-		f.newIndex("packages"),
-		f.logger,
-	)
-}
-
-func (f ReposFactory) NewCompiledPackagesRepo() bpcpkgsrepo.CompiledPackagesRepository {
-	return bpcpkgsrepo.NewConcreteCompiledPackagesRepository(
-		f.newIndex("compiled_packages"),
-		f.logger,
-	)
-}
-
-func (f ReposFactory) newIndex(name string) bpindex.Index {
-	return bpindex.NewFileIndex(filepath.Join(f.dirPath, name+".json"), f.fs)
-}