vagrant-bosh 0.0.3 → 0.0.4

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

@@ -1,6 +1,8 @@
-package vm
+package vagrant
 
 import (
+	"strings"
+
 	bosherr "bosh/errors"
 	boshlog "bosh/logger"
 	boshsys "bosh/system"
@@ -12,20 +14,20 @@ const vcapUserProvisionerLogTag = "VCAPUserProvisioner"
 
 // VCAPUserProvisioner adds and configures vcap user.
 type VCAPUserProvisioner struct {
-	cmds     SimpleCmds
+	fs       boshsys.FileSystem
 	runner   boshsys.CmdRunner
 	eventLog bpeventlog.Log
 	logger   boshlog.Logger
 }
 
 func NewVCAPUserProvisioner(
-	cmds SimpleCmds,
+	fs boshsys.FileSystem,
 	runner boshsys.CmdRunner,
 	eventLog bpeventlog.Log,
 	logger boshlog.Logger,
 ) VCAPUserProvisioner {
 	return VCAPUserProvisioner{
-		cmds:     cmds,
+		fs:       fs,
 		runner:   runner,
 		eventLog: eventLog,
 		logger:   logger,
@@ -33,7 +35,7 @@ func NewVCAPUserProvisioner(
 }
 
 func (p VCAPUserProvisioner) Provision() error {
-	stage := p.eventLog.BeginStage("Setting up vcap user", 2)
+	stage := p.eventLog.BeginStage("Setting up vcap user", 3)
 
 	task := stage.BeginTask("Adding vcap user")
 
@@ -42,6 +44,13 @@ func (p VCAPUserProvisioner) Provision() error {
 		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())
@@ -55,65 +64,103 @@ func (p VCAPUserProvisioner) Provision() error {
 func (p VCAPUserProvisioner) setUpVcapUser() error {
 	p.logger.Info(vcapUserProvisionerLogTag, "Setting up vcap user")
 
-	userBash := `
-    groupadd --system admin
-    useradd -m --comment 'BOSH System User' vcap
+	_, 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
+		}
+	}
 
-    echo "vcap:c1oudc0w" | chpasswd
-    echo "root:c1oudc0w" | chpasswd
+	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
-  `
+		{"usermod", "-G", "admin,adm,audio,cdrom,dialout,floppy,video,dip,plugdev", "vcap"},
+		{"usermod", "-s", "/bin/bash", "vcap"},
+	}
 
-	err := p.cmds.Bash(userBash)
-	if err != nil {
-		return err
+	for _, cmd := range cmds {
+		_, _, _, err := p.runner.RunCommand(cmd[0], cmd[1:]...)
+		if err != nil {
+			return err
+		}
 	}
 
 	// todo setup vcap no-password sudo access
-	_, _, _, err = p.runner.RunCommand("usermod", "-a", "-G", "vcap", "vagrant")
+
+	_, stderr, _, err = p.runner.RunCommand("usermod", "-a", "-G", "vcap", "vagrant")
 	if err != nil {
-		return err
+		if !strings.Contains(stderr, "user 'vagrant' does not exist") {
+			return err
+		}
 	}
 
-	envBashs := []string{
-		"echo 'export PATH=/var/vcap/bosh/bin:$PATH' >> /root/.bashrc",
-		"echo 'export PATH=/var/vcap/bosh/bin:$PATH' >> /home/vcap/.bashrc",
+	return p.setUpBoshBinPath()
+}
 
-		// Configure vcap user locale (postgres initdb fails if mismatched)
-		"echo 'LANG=en_US.UTF-8\nLC_ALL=en_US.UTF-8' > /etc/default/locale",
-	}
+func (p VCAPUserProvisioner) setUpBoshBinPath() error {
+	boshBinExport := "export PATH=/var/vcap/bosh/bin:$PATH"
 
-	for _, bash := range envBashs {
-		err := p.cmds.Bash(bash)
+	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 {
-	permsBash := `
-    echo 'vcap' > /etc/cron.allow
-    echo 'vcap' > /etc/at.allow
+	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", "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/cron.allow"},
+		{"chown", "root:vcap", "/etc/cron.allow"},
 
-    chmod 0640 /etc/at.allow
-    chown root:vcap /etc/at.allow
-  `
+		{"chmod", "0640", "/etc/at.allow"},
+		{"chown", "root:vcap", "/etc/at.allow"},
+	}
 
-	err := p.cmds.Bash(permsBash)
-	if err != nil {
-		return err
+	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,4 +1,4 @@
-package vm
+package vagrant
 
 import (
 	bosherr "bosh/errors"
@@ -8,6 +8,11 @@ import (
 	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 {
@@ -18,12 +23,16 @@ type VMProvisioner struct {
 	// 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
+	// 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,
@@ -40,42 +49,71 @@ func NewVMProvisioner(
 }
 
 func (p *VMProvisioner) Provision(instance bpdep.Instance) (bpvm.VM, error) {
-	var vm VM
-
 	if p.vmProvisioned {
-		return vm, bosherr.New("Vagrant VM is already provisioned")
+		return nil, ErrAlreadyProvisioned
 	}
 
-	if !p.vmPreviouslyProvisioned {
-		err := p.vcapUserProvisioner.Provision()
-		if err != nil {
-			return vm, bosherr.WrapError(err, "Provisioning vcap user")
-		}
+	err := p.provisionNonConfigured()
+	if err != nil {
+		return nil, err
+	}
 
-		err = p.depsProvisioner.Provision()
-		if err != nil {
-			return vm, bosherr.WrapError(err, "Provisioning dependencies")
-		}
+	agentClient, err := p.agentProvisioner.Configure(instance)
+	if err != nil {
+		return nil, bosherr.WrapError(err, "Configuring agent")
 	}
 
-	p.vmPreviouslyProvisioned = true
+	// 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
+	}
 
-	agentClient, err := p.agentProvisioner.Provision(instance)
+	err := p.provisionNonConfigured()
 	if err != nil {
-		return vm, bosherr.WrapError(err, "Provisioning agent")
+		return nil, err
 	}
 
+	// Set this as late as possible so that caller can retry failed provisioning attempts.
 	p.vmProvisioned = true
 
-	return NewVM(p, agentClient), nil
+	return NewNonConfiguredVM(p), nil
 }
 
-func (p *VMProvisioner) Deprovision(vm VM) error {
+func (p *VMProvisioner) deprovision(vm vagrantVM) error {
 	if !p.vmProvisioned {
-		return bosherr.New("Vagrant VM is not provisioned")
+		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,4 +1,4 @@
-package vm
+package vagrant
 
 import (
 	boshlog "bosh/logger"
@@ -26,7 +26,6 @@ func NewVMProvisionerFactory(
 	fs boshsys.FileSystem,
 	runner boshsys.CmdRunner,
 	assetsDir string,
-	mbus string,
 	blobstoreConfig map[string]interface{},
 	vmProvisionerConfig bpvm.VMProvisionerConfig,
 	eventLog bpeventlog.Log,
@@ -36,9 +35,7 @@ func NewVMProvisionerFactory(
 		fs:     fs,
 		runner: runner,
 
-		assetsDir: assetsDir,
-		mbus:      mbus,
-
+		assetsDir:           assetsDir,
 		blobstoreConfig:     blobstoreConfig,
 		vmProvisionerConfig: vmProvisionerConfig,
 
@@ -51,7 +48,7 @@ func (f VMProvisionerFactory) NewVMProvisioner() *VMProvisioner {
 	cmds := NewSimpleCmds(f.runner, f.logger)
 
 	vcapUserProvisioner := NewVCAPUserProvisioner(
-		cmds,
+		f.fs,
 		f.runner,
 		f.eventLog,
 		f.logger,
@@ -88,7 +85,7 @@ func (f VMProvisionerFactory) NewVMProvisioner() *VMProvisioner {
 		runitProvisioner,
 		monitProvisioner,
 		f.blobstoreConfig,
-		f.mbus,
+		f.vmProvisionerConfig.AgentProvisioner,
 		f.eventLog,
 		f.logger,
 	)

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

@@ -6,15 +6,12 @@ import (
 )
 
 type VMProvisioner interface {
-	// Provision creates and configures VM to be usable by BOSH releases.
+	// Provision creates and configures VM for future agent communication.
 	// todo should not rely on bpdep.Instance
 	Provision(bpdep.Instance) (VM, 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"`
+	// ProvisionNonConfigured creates and does NOT configure VM for communication.
+	ProvisionNonConfigured() (VM, error)
 }
 
 type VM interface {
@@ -24,3 +21,25 @@ type VM interface {
 	// 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"`
+}

data/lib/vagrant-bosh/asset_uploader.rb

@@ -5,16 +5,17 @@ require "securerandom"
 module VagrantPlugins
   module VagrantBosh
     class AssetUploader
-      def initialize(communicator, ui, assets_path)
+      def initialize(communicator, assets_dir, ui)
         @c = communicator
+        @assets_dir = assets_dir
+
         @ui = ui.for(:asset_uploader)
-        @assets_path = assets_path
         @logger = Log4r::Logger.new("vagrant::provisioners::bosh::asset_uploader")
       end
 
       def sync(dst_path)
         @ui.timed_msg(:upload, dst_path: dst_path) do
-          upload_path(@assets_path, dst_path)
+          upload_path(@assets_dir, dst_path)
         end
       end
 

data/lib/vagrant-bosh/assets/agent/agent-run

@@ -9,4 +9,7 @@ exec 2>&1
 # Get into directory with agent.{cert,key}
 cd /var/vcap/bosh
 
-exec nice -n -10 /var/vcap/bosh/bin/bosh-agent -I warden -P ubuntu -C /var/vcap/bosh/agent.json
+exec nice -n -10 /var/vcap/bosh/bin/bosh-agent  \
+  -I $(cat /var/vcap/bosh/etc/infrastructure)   \
+  -P $(cat /var/vcap/bosh/etc/platform)         \
+  -C /var/vcap/bosh/agent.json

data/lib/vagrant-bosh/bootstrapper.rb

@@ -4,57 +4,70 @@ require "json"
 module VagrantPlugins
   module VagrantBosh
     class Bootstrapper
-      def initialize(communicator, asset_uploader, base_dir, config, provisioner_tracker)
+      def initialize(communicator, config, asset_uploader, provisioner_tracker, manifest_factory)
         @c = communicator
-        @asset_uploader = asset_uploader
-        @base_dir = base_dir
         @config = config
+        @asset_uploader = asset_uploader
         @provisioner_tracker = provisioner_tracker
-        @logger = Log4r::Logger.new("vagrant::provisioners::bosh::bootstrapper")
+        @manifest_factory = manifest_factory
 
-        @assets_path = File.join(@base_dir, "assets")
-        @repos_path  = File.join(@base_dir, "repos")
-        @manifest_path = File.join(@base_dir, "manifest.yml")
-        @config_path   = File.join(@base_dir, "config.json")
+        @logger = Log4r::Logger.new("vagrant::provisioners::bosh::bootstrapper")
       end
 
       def bootstrap
-        @asset_uploader.sync(@assets_path)
+        @asset_uploader.sync(@config.assets_dir)
 
-        @asset_uploader.upload_text(@config.manifest, @manifest_path)
+        if @config.manifest
+          manifest = @manifest_factory.new_manifest(@config.manifest)
+          manifest.resolve_releases
+          @asset_uploader.upload_text(manifest.as_string, @config.manifest_path)
+        end
 
         config_json = JSON.dump(config_hash)
-        @asset_uploader.upload_text(config_json, @config_path)
+        @asset_uploader.upload_text(config_json, @config.config_path)
+
+        run_provisioner
+      end
+
+      private
 
+      def run_provisioner
         # Provisioner is already uploaded when assets are synced
-        provisioner_path = File.join(@assets_path, "provisioner")
+        provisioner_path = File.join(@config.assets_dir, "provisioner")
         @c.chmod_x(provisioner_path)
 
         @c.sudo(
-          "#{provisioner_path} -configPath=#{@config_path} 2> >(tee /tmp/provisioner.log >&2)",
+          "#{provisioner_path} -configPath=#{@config.config_path} 2> >(tee /tmp/provisioner.log >&2)",
           &@provisioner_tracker.method(:add_data)
         )
       end
 
-      private
-
       def config_hash
         {
-          manifest_path: @manifest_path,
-          assets_dir: @assets_path,
-          repos_dir: @repos_path,
-
-          mbus: "https://user:password@127.0.0.1:4321/agent",
+          assets_dir: @config.assets_dir,
+          repos_dir: @config.repos_dir,
 
           blobstore: {
             provider: "local",
             options: {
-              blobstore_path: File.join(@base_dir, "blobstore"),
+              blobstore_path: @config.local_blobstore_dir,
             },
           },
 
           vm_provisioner: {
             full_stemcell_compatibility: @config.full_stemcell_compatibility,
+
+            agent_provisioner: {
+              infrastructure: @config.agent_infrastructure,
+              platform:       @config.agent_platform,
+              configuration:  @config.agent_configuration,
+
+              mbus: "https://user:password@127.0.0.1:4321/agent",
+            },
+          },
+
+          deployment_provisioner: {
+            manifest_path: (@config.manifest_path if @config.manifest),
           },
         }
       end

data/lib/vagrant-bosh/communicator.rb

@@ -5,6 +5,7 @@ module VagrantPlugins
     class Communicator
       def initialize(machine, ui)
         @c = machine.communicate
+
         @ui = ui.for(:communicator)
         @logger = Log4r::Logger.new("vagrant::provisioners::bosh::communicator")
       end

data/lib/vagrant-bosh/config.rb

@@ -3,6 +3,14 @@ require "vagrant"
 module VagrantPlugins
   module VagrantBosh
     class Config < Vagrant.plugin("2", :config)
+      attr_accessor :base_dir
+
+      attr_reader :assets_dir, :repos_dir
+
+      attr_reader :manifest_path, :config_path
+
+      attr_reader :local_blobstore_dir, :synced_releases_dir
+
       # Manifest holds full BOSH deployment manifest as a string.
       attr_accessor :manifest
 
@@ -10,8 +18,24 @@ module VagrantPlugins
       # (not just minimum) dependencies usually found on a stemcell.
       attr_accessor :full_stemcell_compatibility
 
+      attr_accessor :agent_infrastructure, :agent_platform, :agent_configuration
+
+      def initialize(*args)
+        super
+        @base_dir = "/opt/vagrant-bosh"
+      end
+
       def finalize!
-        self.full_stemcell_compatibility = !!self.full_stemcell_compatibility
+        @assets_dir = File.join(@base_dir, "assets")
+        @repos_dir  = File.join(@base_dir, "repos")
+
+        @manifest_path = File.join(@base_dir, "manifest.yml")
+        @config_path   = File.join(@base_dir, "config.json")
+
+        @local_blobstore_dir = File.join(@base_dir, "blobstore")
+        @synced_releases_dir = File.join(@base_dir, "synced-releases")
+
+        @full_stemcell_compatibility = !!@full_stemcell_compatibility
       end
 
       def validate(machine)

data/lib/vagrant-bosh/deployment/manifest.rb

@@ -0,0 +1,79 @@
+require "log4r"
+require "yaml"
+
+module VagrantPlugins
+  module VagrantBosh
+    module Deployment
+      class Manifest
+        def initialize(manifest, uploadable_release_factory, ui)
+          @manifest = manifest
+          @uploadable_release_factory = uploadable_release_factory
+
+          @ui = ui.for(:deployment, :manifest)
+          @logger = Log4r::Logger.new("vagrant::provisioners::bosh::deployment::manifest")
+        end
+
+        # Syncs releases to guest FS and rewrites manifest to reference guest FS locations.
+        def resolve_releases
+          uploaded_releases = uploadable_releases.map(&:upload)
+
+          parsed_releases.each do |release|
+            uploaded_releases.each do |uploaded_release|
+              if release["name"] == uploaded_release.name
+                release.merge!(uploaded_release.as_hash)
+              end
+            end
+          end
+
+          nil # ah
+        end
+
+        def as_string
+          YAML.dump(parsed_manifest)
+        end
+
+        private
+
+        # Returns releases with url matching `dir+bosh://...`
+        def uploadable_releases
+          parsed_releases.map { |release|
+            next unless url = release["url"]
+            next unless url =~ %r{\Adir\+bosh://(.+)\z}
+
+            @uploadable_release_factory.new_uploadable_release(
+              release["name"], 
+              release["version"], 
+              $1, # host_dir
+            )
+          }.compact
+        end
+
+        def parsed_releases
+          parsed_manifest["releases"] || []
+        end
+
+        def parsed_manifest
+          return @parsed_manifest if @parsed_manifest
+
+          begin
+            @parsed_manifest = YAML.load(@manifest)
+          rescue SyntaxError => e
+            error_msg = @ui.msg_string(:parse_error, details: e.inspect)
+            raise VagrantPlugins::VagrantBosh::Errors::BoshReleaseError, error_msg
+          end
+
+          unless @parsed_manifest.is_a?(Hash)
+            error_msg = @ui.msg_string(:non_hash_class_error, {
+              actual_class: parsed_manifest.class.to_s,
+            })
+            raise VagrantPlugins::VagrantBosh::Errors::BoshReleaseError, error_msg
+          end
+
+          @parsed_manifest
+        end
+      end
+
+      #~
+    end
+  end
+end