vagrantup 1.0.7 → 1.1.0

data/plugins/provisioners/puppet/plugin.rb

@@ -0,0 +1,33 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Puppet
+    class Plugin < Vagrant.plugin("2")
+      name "puppet"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      Puppet either using `puppet apply` or a Puppet server.
+      DESC
+
+      config(:puppet, :provisioner) do
+        require File.expand_path("../config/puppet", __FILE__)
+        Config::Puppet
+      end
+
+      config(:puppet_server, :provisioner) do
+        require File.expand_path("../config/puppet_server", __FILE__)
+        Config::PuppetServer
+      end
+
+      provisioner(:puppet) do
+        require File.expand_path("../provisioner/puppet", __FILE__)
+        Provisioner::Puppet
+      end
+
+      provisioner(:puppet_server) do
+        require File.expand_path("../provisioner/puppet_server", __FILE__)
+        Provisioner::PuppetServer
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/provisioner/puppet.rb

@@ -0,0 +1,110 @@
+require "log4r"
+
+module VagrantPlugins
+  module Puppet
+    module Provisioner
+      class PuppetError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant.provisioners.puppet")
+      end
+
+      class Puppet < Vagrant.plugin("2", :provisioner)
+        def initialize(machine, config)
+          super
+
+          @logger = Log4r::Logger.new("vagrant::provisioners::puppet")
+        end
+
+        def configure(root_config)
+          # Calculate the paths we're going to use based on the environment
+          root_path = @machine.env.root_path
+          @expanded_manifests_path = @config.expanded_manifests_path(root_path)
+          @expanded_module_paths   = @config.expanded_module_paths(root_path)
+          @manifest_file           = File.join(manifests_guest_path, @config.manifest_file)
+
+          # Setup the module paths
+          @module_paths = []
+          @expanded_module_paths.each_with_index do |path, i|
+            @module_paths << [path, File.join(config.pp_path, "modules-#{i}")]
+          end
+
+          # Share the manifests directory with the guest
+          root_config.vm.synced_folder(
+            @expanded_manifests_path, manifests_guest_path)
+
+          # Share the module paths
+          count = 0
+          @module_paths.each do |from, to|
+            # Sorry for the cryptic key here, but VirtualBox has a strange limit on
+            # maximum size for it and its something small (around 10)
+            root_config.vm.synced_folder(from, to)
+            count += 1
+          end
+        end
+
+        def provision
+          # Check that the shared folders are properly shared
+          check = [manifests_guest_path]
+          @module_paths.each do |host_path, guest_path|
+            check << guest_path
+          end
+
+          verify_shared_folders(check)
+
+          # Verify Puppet is installed and run it
+          verify_binary("puppet")
+          run_puppet_apply
+        end
+
+        def manifests_guest_path
+          File.join(config.pp_path, "manifests")
+        end
+
+        def verify_binary(binary)
+          @machine.communicate.sudo(
+            "which #{binary}",
+            :error_class => PuppetError,
+            :error_key => :not_detected,
+            :binary => binary)
+        end
+
+        def run_puppet_apply
+          options = [config.options].flatten
+          module_paths = @module_paths.map { |_, to| to }
+          options << "--modulepath '#{module_paths.join(':')}'" if !@module_paths.empty?
+          options << @manifest_file
+          options = options.join(" ")
+
+          # Build up the custom facts if we have any
+          facter = ""
+          if !config.facter.empty?
+            facts = []
+            config.facter.each do |key, value|
+              facts << "FACTER_#{key}='#{value}'"
+            end
+
+            facter = "#{facts.join(" ")} "
+          end
+
+          command = "cd #{manifests_guest_path} && #{facter}puppet apply #{options} --detailed-exitcodes || [ $? -eq 2 ]"
+
+          @machine.env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet",
+                                      :manifest => @manifest_file)
+
+          @machine.communicate.sudo(command) do |type, data|
+            data.chomp!
+            @machine.env.ui.info(data, :prefix => false) if !data.empty?
+          end
+        end
+
+        def verify_shared_folders(folders)
+          folders.each do |folder|
+            @logger.debug("Checking for shared folder: #{folder}")
+            if !@machine.communicate.test("test -d #{folder}")
+              raise PuppetError, :missing_shared_folders
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/puppet/provisioner/puppet_server.rb

@@ -0,0 +1,67 @@
+module VagrantPlugins
+  module Puppet
+    module Provisioner
+      class PuppetServerError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant.provisioners.puppet_server")
+      end
+
+      class PuppetServer < Vagrant.plugin("2", :provisioner)
+        def provision
+          verify_binary("puppet")
+          run_puppet_agent
+        end
+
+        def verify_binary(binary)
+          @machine.communicate.sudo(
+            "which #{binary}",
+            :error_class => PuppetServerError,
+            :error_key => :not_detected,
+            :binary => binary)
+        end
+
+        def run_puppet_agent
+          options = config.options
+          options = [options] if !options.is_a?(Array)
+
+          # Intelligently set the puppet node cert name based on certain
+          # external parameters.
+          cn = nil
+          if config.puppet_node
+            # If a node name is given, we use that directly for the certname
+            cn = config.puppet_node
+          elsif @machine.config.vm.host_name
+            # If a host name is given, we explicitly set the certname to
+            # nil so that the hostname becomes the cert name.
+            cn = nil
+          else
+            # Otherwise, we default to the name of the box.
+            cn = @machine.config.vm.box
+          end
+
+          # Add the certname option if there is one
+          options += ["--certname", cn] if cn
+          options = options.join(" ")
+
+          # Build up the custom facts if we have any
+          facter = ""
+          if !config.facter.empty?
+            facts = []
+            config.facter.each do |key, value|
+              facts << "FACTER_#{key}='#{value}'"
+            end
+
+            facter = "#{facts.join(" ")} "
+          end
+
+          command = "#{facter}puppet agent #{options} --server #{config.puppet_server} --detailed-exitcodes || [ $? -eq 2 ]"
+
+          @machine.env.ui.info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
+          @machine.communicate.sudo(command) do |type, data|
+            data.chomp!
+            @machine.env.ui.info(data, :prefix => false) if !data.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/provisioners/shell/config.rb

@@ -0,0 +1,46 @@
+module VagrantPlugins
+  module Shell
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :inline
+      attr_accessor :path
+      attr_accessor :upload_path
+      attr_accessor :args
+
+      def initialize
+        @upload_path = "/tmp/vagrant-shell"
+      end
+
+      def validate(machine)
+        errors = []
+
+        # Validate that the parameters are properly set
+        if path && inline
+          errors << I18n.t("vagrant.provisioners.shell.path_and_inline_set")
+        elsif !path && !inline
+          errors << I18n.t("vagrant.provisioners.shell.no_path_or_inline")
+        end
+
+        # Validate the existence of a script to upload
+        if path
+          expanded_path = Pathname.new(path).expand_path(machine.env.root_path)
+          if !expanded_path.file?
+            errors << I18n.t("vagrant.provisioners.shell.path_invalid",
+                              :path => expanded_path)
+          end
+        end
+
+        # There needs to be a path to upload the script to
+        if !upload_path
+          errors << I18n.t("vagrant.provisioners.shell.upload_path_not_set")
+        end
+
+        # If there are args and its not a string, that is a problem
+        if args && !args.is_a?(String)
+          errors << I18n.t("vagrant.provisioners.shell.args_not_string")
+        end
+
+        { "shell provisioner" => errors }
+      end
+    end
+  end
+end

data/plugins/provisioners/shell/plugin.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Shell
+    class Plugin < Vagrant.plugin("2")
+      name "shell"
+      description <<-DESC
+      Provides support for provisioning your virtual machines with
+      shell scripts.
+      DESC
+
+      config(:shell, :provisioner) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+
+      provisioner(:shell) do
+        require File.expand_path("../provisioner", __FILE__)
+        Provisioner
+      end
+    end
+  end
+end

data/plugins/provisioners/shell/provisioner.rb

@@ -0,0 +1,66 @@
+require "pathname"
+require "tempfile"
+
+module VagrantPlugins
+  module Shell
+    class Provisioner < Vagrant.plugin("2", :provisioner)
+      def provision
+        args = ""
+        args = " #{config.args}" if config.args
+        command = "chmod +x #{config.upload_path} && #{config.upload_path}#{args}"
+
+        with_script_file do |path|
+          # Upload the script to the machine
+          @machine.communicate.tap do |comm|
+            comm.upload(path.to_s, config.upload_path)
+
+            # Execute it with sudo
+            comm.sudo(command) do |type, data|
+              if [:stderr, :stdout].include?(type)
+                # Output the data with the proper color based on the stream.
+                color = type == :stdout ? :green : :red
+
+                # Note: Be sure to chomp the data to avoid the newlines that the
+                # Chef outputs.
+                @machine.env.ui.info(data.chomp, :color => color, :prefix => false)
+              end
+            end
+          end
+        end
+      end
+
+      protected
+
+      # This method yields the path to a script to upload and execute
+      # on the remote server. This method will properly clean up the
+      # script file if needed.
+      def with_script_file
+        if config.path
+          # Just yield the path to that file...
+          root_path = @machine.env.root_path
+          yield Pathname.new(config.path).expand_path(root_path)
+          return
+        end
+
+        # Otherwise we have an inline script, we need to Tempfile it,
+        # and handle it specially...
+        file = Tempfile.new('vagrant-shell')
+
+        # Unless you set binmode, on a Windows host the shell script will
+        # have CRLF line endings instead of LF line endings, causing havoc
+        # when the guest executes it. This fixes [GH-1181].
+        file.binmode
+
+        begin
+          file.write(config.inline)
+          file.fsync
+          file.close
+          yield file.path
+        ensure
+          file.close
+          file.unlink
+        end
+      end
+    end
+  end
+end

data/templates/commands/init/Vagrantfile.erb

@@ -1,7 +1,7 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-Vagrant::Config.run do |config|
+Vagrant.configure("2") do |config|
   # All Vagrant configuration is done here. The most common configuration
   # options are documented and commented below. For a complete reference,
   # please see the online documentation at vagrantup.com.
@@ -13,28 +13,40 @@ Vagrant::Config.run do |config|
   # doesn't already exist on the user's system.
   <% if box_url.nil? %># <% end %>config.vm.box_url = "<%= box_url || "http://domain.com/path/to/above.box" %>"
 
-  # Boot with a GUI so you can see the screen. (Default is headless)
-  # config.vm.boot_mode = :gui
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine. In the example below,
+  # accessing "localhost:8080" will access port 80 on the guest machine.
+  # config.vm.network :forwarded_port, guest: 80, host: 8080
 
-  # Assign this VM to a host-only network IP, allowing you to access it
-  # via the IP. Host-only networks can talk to the host machine as well as
-  # any other machines on the same network, but cannot be accessed (through this
-  # network interface) by any external networks.
-  # config.vm.network :hostonly, "192.168.33.10"
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  # config.vm.network :private_network, ip: "192.168.33.10"
 
-  # Assign this VM to a bridged network, allowing you to connect directly to a
-  # network using the host's network device. This makes the VM appear as another
-  # physical device on your network.
-  # config.vm.network :bridged
-
-  # Forward a port from the guest to the host, which allows for outside
-  # computers to access the VM, whereas host only networking does not.
-  # config.vm.forward_port 80, 8080
+  # Create a public network, which generally matched to bridged network.
+  # Bridged networks make the machine appear as another physical device on
+  # your network.
+  # config.vm.network :public_network
 
   # Share an additional folder to the guest VM. The first argument is
-  # an identifier, the second is the path on the guest to mount the
-  # folder, and the third is the path on the host to the actual folder.
-  # config.vm.share_folder "v-data", "/vagrant_data", "../data"
+  # the path on the host to the actual folder. The second argument is
+  # the path on the guest to mount the folder. And the optional third
+  # argument is a set of non-required options.
+  # config.vm.synced_folder "../data", "/vagrant_data"
+
+  # Provider-specific configuration so you can fine-tune various
+  # backing providers for Vagrant. These expose provider-specific options.
+  # Example for VirtualBox:
+  #
+  # config.vm.provider :virtualbox do |vb|
+  #   # Don't boot with headless mode
+  #   vb.gui = true
+  #
+  #   # Use VBoxManage to customize the VM. For example to change memory:
+  #   vb.customize ["modifyvm", :id, "--memory", "1024"]
+  # end
+  #
+  # View the documentation for the provider you're using for more
+  # information on available options.
 
   # Enable provisioning with Puppet stand alone.  Puppet manifests
   # are contained in a directory path relative to this Vagrantfile.
@@ -60,7 +72,7 @@ Vagrant::Config.run do |config|
   # end
 
   # Enable provisioning with chef solo, specifying a cookbooks path, roles
-  # path, and data_bags path (all relative to this Vagrantfile), and adding 
+  # path, and data_bags path (all relative to this Vagrantfile), and adding
   # some recipes and/or roles.
   #
   # config.vm.provision :chef_solo do |chef|
@@ -92,7 +104,7 @@ Vagrant::Config.run do |config|
   # If you're using the Opscode platform, your validator client is
   # ORGNAME-validator, replacing ORGNAME with your organization name.
   #
-  # IF you have your own Chef Server, the default validation client name is
+  # If you have your own Chef Server, the default validation client name is
   # chef-validator, unless you changed the configuration.
   #
   #   chef.validation_client_name = "ORGNAME-validator"

data/templates/commands/ssh_config/config.erb

@@ -7,6 +7,7 @@ Host <%= host_key %>
   PasswordAuthentication no
   IdentityFile "<%= private_key_path %>"
   IdentitiesOnly yes
+  LogLevel FATAL
 <% if forward_agent -%>
   ForwardAgent yes
 <% end -%>

data/templates/config/messages.erb

@@ -0,0 +1,14 @@
+<% if !warnings.empty? -%>
+Warnings:
+<% warnings.each do |warning| -%>
+* <%= warning %>
+<% end -%>
+
+<% end -%>
+<% if !errors.empty? -%>
+Errors:
+<% errors.each do |error| -%>
+* <%= error %>
+<% end -%>
+
+<% end -%>