vagrant-bosh 0.0.6 → 0.0.7

data/go/src/boshprovisioner/vm/vagrant/simple_cmds.go

@@ -1,54 +0,0 @@
-package vagrant
-
-import (
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-)
-
-type SimpleCmds struct {
-	runner boshsys.CmdRunner
-	logger boshlog.Logger
-}
-
-func NewSimpleCmds(
-	runner boshsys.CmdRunner,
-	logger boshlog.Logger,
-) SimpleCmds {
-	return SimpleCmds{
-		runner: runner,
-		logger: logger,
-	}
-}
-
-func (r SimpleCmds) MkdirP(path string) error {
-	return r.run("mkdir", "-p", path)
-}
-
-func (r SimpleCmds) ChmodX(path string) error {
-	return r.run("chmod", "+x", path)
-}
-
-func (r SimpleCmds) Touch(path string) error {
-	return r.run("touch", path)
-}
-
-func (r SimpleCmds) Mv(srcPath, dstPath string) error {
-	return r.run("mv", srcPath, dstPath)
-}
-
-func (r SimpleCmds) Chmod(mode, path string) error {
-	return r.run("chmod", mode, path)
-}
-
-func (r SimpleCmds) Chown(user, group, path string) error {
-	return r.run("chmod", user+":"+group, path)
-}
-
-func (r SimpleCmds) Bash(script string) error {
-	return r.run("bash", "-c", script)
-}
-
-func (r SimpleCmds) run(cmd string, args ...string) error {
-	_, _, _, err := r.runner.RunCommand(cmd, args...)
-	return err
-}

data/go/src/boshprovisioner/vm/vagrant/vcap_user_provisioner.go

@@ -1,167 +0,0 @@
-package vagrant
-
-import (
-	"strings"
-
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-
-	bpeventlog "boshprovisioner/eventlog"
-)
-
-const vcapUserProvisionerLogTag = "VCAPUserProvisioner"
-
-// VCAPUserProvisioner adds and configures vcap user.
-type VCAPUserProvisioner struct {
-	fs       boshsys.FileSystem
-	runner   boshsys.CmdRunner
-	eventLog bpeventlog.Log
-	logger   boshlog.Logger
-}
-
-func NewVCAPUserProvisioner(
-	fs boshsys.FileSystem,
-	runner boshsys.CmdRunner,
-	eventLog bpeventlog.Log,
-	logger boshlog.Logger,
-) VCAPUserProvisioner {
-	return VCAPUserProvisioner{
-		fs:       fs,
-		runner:   runner,
-		eventLog: eventLog,
-		logger:   logger,
-	}
-}
-
-func (p VCAPUserProvisioner) Provision() error {
-	stage := p.eventLog.BeginStage("Setting up vcap user", 3)
-
-	task := stage.BeginTask("Adding vcap user")
-
-	err := task.End(p.setUpVcapUser())
-	if err != nil {
-		return bosherr.WrapError(err, "Setting up vcap user")
-	}
-
-	task = stage.BeginTask("Configuring locales")
-
-	err = task.End(p.configureLocales())
-	if err != nil {
-		return bosherr.WrapError(err, "Configuring locales")
-	}
-
-	task = stage.BeginTask("Harden permissions")
-
-	err = task.End(p.hardenPermissinons())
-	if err != nil {
-		return bosherr.WrapError(err, "Harden permissions")
-	}
-
-	return nil
-}
-
-func (p VCAPUserProvisioner) setUpVcapUser() error {
-	p.logger.Info(vcapUserProvisionerLogTag, "Setting up vcap user")
-
-	_, stderr, _, err := p.runner.RunCommand("groupadd", "--system", "admin")
-	if err != nil {
-		if !strings.Contains(stderr, "group 'admin' already exists") {
-			return err
-		}
-	}
-
-	_, stderr, _, err = p.runner.RunCommand("useradd", "-m", "--comment", "BOSH System User", "vcap")
-	if err != nil {
-		if !strings.Contains(stderr, "user 'vcap' already exists") {
-			return err
-		}
-	}
-
-	cmds := [][]string{
-		{"bash", "-c", "echo 'vcap:c1oudc0w' | chpasswd"},
-		{"bash", "-c", "echo 'root:c1oudc0w' | chpasswd"},
-
-		{"usermod", "-G", "admin,adm,audio,cdrom,dialout,floppy,video,dip,plugdev", "vcap"},
-		{"usermod", "-s", "/bin/bash", "vcap"},
-	}
-
-	for _, cmd := range cmds {
-		_, _, _, err := p.runner.RunCommand(cmd[0], cmd[1:]...)
-		if err != nil {
-			return err
-		}
-	}
-
-	// todo setup vcap no-password sudo access
-
-	_, stderr, _, err = p.runner.RunCommand("usermod", "-a", "-G", "vcap", "vagrant")
-	if err != nil {
-		if !strings.Contains(stderr, "user 'vagrant' does not exist") {
-			return err
-		}
-	}
-
-	return p.setUpBoshBinPath()
-}
-
-func (p VCAPUserProvisioner) setUpBoshBinPath() error {
-	boshBinExport := "export PATH=/var/vcap/bosh/bin:$PATH"
-
-	for _, bashrcPath := range []string{"/root/.bashrc", "/home/vcap/.bashrc"} {
-		contents, err := p.fs.ReadFileString(bashrcPath)
-		if err != nil {
-			return err
-		}
-
-		if !strings.Contains(contents, boshBinExport) {
-			err := p.fs.WriteFileString(bashrcPath, contents+"\n"+boshBinExport+"\n")
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func (p VCAPUserProvisioner) configureLocales() error {
-	_, _, _, err := p.runner.RunCommand("locale-gen", "en_US.UTF-8")
-	if err != nil {
-		return err
-	}
-
-	_, _, _, err = p.runner.RunCommand("dpkg-reconfigure", "locales")
-	if err != nil {
-		return err
-	}
-
-	// Configure vcap user locale (postgres initdb fails if mismatched)
-	return p.fs.WriteFileString("/etc/default/locale", "LANG=en_US.UTF-8\nLC_ALL=en_US.UTF-8")
-}
-
-func (p VCAPUserProvisioner) hardenPermissinons() error {
-	cmds := [][]string{
-		{"bash", "-c", "echo 'vcap' > /etc/cron.allow"},
-		{"bash", "-c", "echo 'vcap' > /etc/at.allow"},
-
-		{"chmod", "0770", "/var/lock"},
-		{"chown", "-h", "root:vcap", "/var/lock"},
-		{"chown", "-LR", "root:vcap", "/var/lock"},
-
-		{"chmod", "0640", "/etc/cron.allow"},
-		{"chown", "root:vcap", "/etc/cron.allow"},
-
-		{"chmod", "0640", "/etc/at.allow"},
-		{"chown", "root:vcap", "/etc/at.allow"},
-	}
-
-	for _, cmd := range cmds {
-		_, _, _, err := p.runner.RunCommand(cmd[0], cmd[1:]...)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}

data/go/src/boshprovisioner/vm/vagrant/vm_provisioner.go

@@ -1,119 +0,0 @@
-package vagrant
-
-import (
-	bosherr "bosh/errors"
-	boshlog "bosh/logger"
-
-	bpdep "boshprovisioner/deployment"
-	bpvm "boshprovisioner/vm"
-)
-
-var (
-	ErrAlreadyProvisioned = bosherr.New("Vagrant VM is already provisioned")
-	ErrNotProvisioned     = bosherr.New("Vagrant VM is not provisioned")
-)
-
-// VMProvisioner installs system dependencies that are usually
-// found on a stemcell, adds vcap user and finally install Agent and Monit.
-type VMProvisioner struct {
-	vcapUserProvisioner VCAPUserProvisioner
-	depsProvisioner     DepsProvisioner
-	agentProvisioner    AgentProvisioner
-
-	// Cannot provision more than 1 VM at a time until previous VM is deprovisioned.
-	vmProvisioned bool
-
-	// Remember if we have recently run provisioning for a VM to skip it next time.
-	vmPreviouslyProvisioned bool
-
-	logger boshlog.Logger
-}
-
-type vagrantVM interface {
-	vagrantVM()
-}
-
-func NewVMProvisioner(
-	vcapUserProvisioner VCAPUserProvisioner,
-	depsProvisioner DepsProvisioner,
-	agentProvisioner AgentProvisioner,
-	logger boshlog.Logger,
-) *VMProvisioner {
-	return &VMProvisioner{
-		vcapUserProvisioner: vcapUserProvisioner,
-		depsProvisioner:     depsProvisioner,
-		agentProvisioner:    agentProvisioner,
-
-		logger: logger,
-	}
-}
-
-func (p *VMProvisioner) Provision(instance bpdep.Instance) (bpvm.VM, error) {
-	if p.vmProvisioned {
-		return nil, ErrAlreadyProvisioned
-	}
-
-	err := p.provisionNonConfigured()
-	if err != nil {
-		return nil, err
-	}
-
-	agentClient, err := p.agentProvisioner.Configure(instance)
-	if err != nil {
-		return nil, bosherr.WrapError(err, "Configuring agent")
-	}
-
-	// Set this as late as possible so that caller can retry failed provisioning attempts.
-	p.vmProvisioned = true
-
-	return NewConfiguredVM(p, agentClient), nil
-}
-
-func (p *VMProvisioner) ProvisionNonConfigured() (bpvm.VM, error) {
-	if p.vmProvisioned {
-		return nil, ErrAlreadyProvisioned
-	}
-
-	err := p.provisionNonConfigured()
-	if err != nil {
-		return nil, err
-	}
-
-	// Set this as late as possible so that caller can retry failed provisioning attempts.
-	p.vmProvisioned = true
-
-	return NewNonConfiguredVM(p), nil
-}
-
-func (p *VMProvisioner) deprovision(vm vagrantVM) error {
-	if !p.vmProvisioned {
-		return ErrNotProvisioned
-	}
-
-	p.vmProvisioned = false
-
-	return nil
-}
-
-func (p *VMProvisioner) provisionNonConfigured() error {
-	if !p.vmPreviouslyProvisioned {
-		err := p.vcapUserProvisioner.Provision()
-		if err != nil {
-			return bosherr.WrapError(err, "Provisioning vcap user")
-		}
-
-		err = p.depsProvisioner.Provision()
-		if err != nil {
-			return bosherr.WrapError(err, "Provisioning dependencies")
-		}
-	}
-
-	p.vmPreviouslyProvisioned = true
-
-	err := p.agentProvisioner.Provision()
-	if err != nil {
-		return bosherr.WrapError(err, "Provisioning agent")
-	}
-
-	return nil
-}

data/go/src/boshprovisioner/vm/vagrant/vm_provisioner_factory.go

@@ -1,101 +0,0 @@
-package vagrant
-
-import (
-	boshlog "bosh/logger"
-	boshsys "bosh/system"
-
-	bpeventlog "boshprovisioner/eventlog"
-	bpvm "boshprovisioner/vm"
-)
-
-type VMProvisionerFactory struct {
-	fs     boshsys.FileSystem
-	runner boshsys.CmdRunner
-
-	assetsDir string
-	mbus      string
-
-	blobstoreConfig     map[string]interface{}
-	vmProvisionerConfig bpvm.VMProvisionerConfig
-
-	eventLog bpeventlog.Log
-	logger   boshlog.Logger
-}
-
-func NewVMProvisionerFactory(
-	fs boshsys.FileSystem,
-	runner boshsys.CmdRunner,
-	assetsDir string,
-	blobstoreConfig map[string]interface{},
-	vmProvisionerConfig bpvm.VMProvisionerConfig,
-	eventLog bpeventlog.Log,
-	logger boshlog.Logger,
-) VMProvisionerFactory {
-	return VMProvisionerFactory{
-		fs:     fs,
-		runner: runner,
-
-		assetsDir:           assetsDir,
-		blobstoreConfig:     blobstoreConfig,
-		vmProvisionerConfig: vmProvisionerConfig,
-
-		eventLog: eventLog,
-		logger:   logger,
-	}
-}
-
-func (f VMProvisionerFactory) NewVMProvisioner() *VMProvisioner {
-	cmds := NewSimpleCmds(f.runner, f.logger)
-
-	vcapUserProvisioner := NewVCAPUserProvisioner(
-		f.fs,
-		f.runner,
-		f.eventLog,
-		f.logger,
-	)
-
-	assetManager := NewAssetManager(f.assetsDir, f.fs, f.runner, f.logger)
-
-	runitProvisioner := NewRunitProvisioner(
-		f.fs,
-		cmds,
-		f.runner,
-		assetManager,
-		f.logger,
-	)
-
-	monitProvisioner := NewMonitProvisioner(
-		cmds,
-		assetManager,
-		runitProvisioner,
-		f.logger,
-	)
-
-	depsProvisioner := NewDepsProvisioner(
-		f.vmProvisionerConfig.FullStemcellCompatibility,
-		f.runner,
-		f.eventLog,
-		f.logger,
-	)
-
-	agentProvisioner := NewAgentProvisioner(
-		f.fs,
-		cmds,
-		assetManager,
-		runitProvisioner,
-		monitProvisioner,
-		f.blobstoreConfig,
-		f.vmProvisionerConfig.AgentProvisioner,
-		f.eventLog,
-		f.logger,
-	)
-
-	vmProvisioner := NewVMProvisioner(
-		vcapUserProvisioner,
-		depsProvisioner,
-		agentProvisioner,
-		f.logger,
-	)
-
-	return vmProvisioner
-}

data/go/src/boshprovisioner/vm/vm_interface.go

@@ -1,45 +0,0 @@
-package vm
-
-import (
-	bpagclient "boshprovisioner/agent/client"
-	bpdep "boshprovisioner/deployment"
-)
-
-type VMProvisioner interface {
-	// Provision creates and configures VM for future agent communication.
-	// todo should not rely on bpdep.Instance
-	Provision(bpdep.Instance) (VM, error)
-
-	// ProvisionNonConfigured creates and does NOT configure VM for communication.
-	ProvisionNonConfigured() (VM, error)
-}
-
-type VM interface {
-	// AgentClient returns a client immediately ready for communication.
-	AgentClient() bpagclient.Client
-
-	// Deprovision deletes VM previously provisioned VM.
-	Deprovision() error
-}
-
-type VMProvisionerConfig struct {
-	// When provisioning, install all dependencies that official stemcells carry.
-	// By default, provisioners will only install absolutely needed dependencies.
-	FullStemcellCompatibility bool `json:"full_stemcell_compatibility"`
-
-	AgentProvisioner AgentProvisionerConfig `json:"agent_provisioner"`
-}
-
-type AgentProvisionerConfig struct {
-	// e.g. warden, aws
-	Infrastructure string `json:"infrastructure"`
-
-	// e.g. ubuntu, centos
-	Platform string `json:"platform"`
-
-	// Usually save to /var/vcap/bosh/agent.json
-	Configuration map[string]interface{} `json:"configuration"`
-
-	// e.g. "https://user:password@127.0.0.1:4321/agent"
-	Mbus string `json:"mbus"`
-}