tnargav 1.2.2

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

@@ -0,0 +1,117 @@
+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           = @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 }
+          if !@module_paths.empty?
+            # Prepend the default module path
+            module_paths.unshift("/etc/puppet/modules")
+
+            # Add the command line switch to add the module path
+            options << "--modulepath '#{module_paths.join(':')}'"
+          end
+
+          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.hostname
+            # 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,56 @@
+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
+        @args        = UNSET_VALUE
+        @inline      = UNSET_VALUE
+        @path        = UNSET_VALUE
+        @upload_path = UNSET_VALUE
+      end
+
+      def finalize!
+        @args        = nil if @args == UNSET_VALUE
+        @inline      = nil if @inline == UNSET_VALUE
+        @path        = nil if @path == UNSET_VALUE
+        @upload_path = "/tmp/vagrant-shell" if @upload_path == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_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,86 @@
+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|
+            # Reset upload path permissions for the current ssh user
+            user = @machine.ssh_info[:username]
+            comm.sudo("chown -R #{user} #{config.upload_path}",
+                      :error_check => false)
+
+            comm.upload(path.to_s, config.upload_path)
+
+            if config.path
+              @machine.ui.info(I18n.t("vagrant.provisioners.shell.running",
+                                      script: path.to_s))
+            else
+              @machine.ui.info(I18n.t("vagrant.provisioners.shell.running",
+                                      script: "inline script"))
+            end
+
+            # 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
+        script = nil
+
+        if config.path
+          # Just yield the path to that file...
+          root_path = @machine.env.root_path
+          script = Pathname.new(config.path).expand_path(root_path).read
+        else
+          # The script is just the inline code...
+          script = config.inline
+        end
+
+        # Replace Windows line endings with Unix ones
+        script.gsub!(/\r\n?$/, "\n")
+
+        # 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(script)
+          file.fsync
+          file.close
+          yield file.path
+        ensure
+          file.close
+          file.unlink
+        end
+      end
+    end
+  end
+end

data/tasks/acceptance.rake

@@ -0,0 +1,113 @@
+require 'digest/sha1'
+require 'net/http'
+require 'pathname'
+require 'uri'
+require 'yaml'
+
+require 'childprocess'
+
+require 'vagrant/util/file_checksum'
+
+namespace :acceptance do
+  desc "Downloads the boxes required for running the acceptance tests."
+  task :boxes, :directory do |t, args|
+    # Create the directory where the boxes will be downloaded
+    box_dir = Pathname.new(args[:directory] || File.expand_path("../../boxes", __FILE__))
+    box_dir.mkpath
+    puts "Boxes will be placed in: #{box_dir}"
+
+    # Load the required boxes
+    boxes = YAML.load_file(File.expand_path("../../test/config/acceptance_boxes.yml", __FILE__))
+
+    boxes.each do |box|
+      puts "Box: #{box["name"]}"
+      box_file = box_dir.join("#{box["name"]}.box")
+      checksum = FileChecksum.new(box_file, Digest::SHA1)
+
+      # If the box exists, we need to check the checksum and determine if we need
+      # to redownload the file.
+      if box_file.exist?
+        print "Box exists, checking SHA1 sum... "
+        if checksum.checksum == box["checksum"]
+          print "OK\n"
+          next
+        else
+          print "FAIL\n"
+        end
+      end
+
+      # Download the file. Note that this has no error checking and just uses
+      # pure net/http. There could be a better way.
+      puts "Downloading: #{box["url"]}"
+      destination = box_file.open("wb")
+      uri = URI.parse(box["url"])
+      Net::HTTP.new(uri.host, uri.port).start do |http|
+        http.request_get(uri.request_uri) do |response|
+          total = response.content_length
+          progress = 0
+          count = 0
+
+          response.read_body do |segment|
+            # Really elementary progress meter
+            progress += segment.length
+            count += 1
+            puts "Progress: #{(progress.to_f / total.to_f) * 100}%" if count % 300 == 0
+
+            # Write out to the destination file
+            destination.write(segment)
+          end
+        end
+      end
+
+      destination.close
+
+      # Check the checksum of the new file to verify that it
+      # downloaded properly. This shouldn't happen, but it can!
+      if checksum.checksum != box["checksum"]
+        puts "Checksum didn't match! Download was corrupt!"
+        abort
+      end
+    end
+  end
+
+  desc "Generates the configuration for acceptance tests from current source."
+  task :config, :box_dir do |t, args|
+    require File.expand_path("../../lib/vagrant/version", __FILE__)
+    require File.expand_path('../../test/support/tempdir', __FILE__)
+
+    # Get the directory for the boxes
+    box_dir = Pathname.new(args[:box_dir] || File.expand_path("../../boxes", __FILE__))
+
+    # Generate the binstubs for the Vagrant binary
+    tempdir = Tempdir.new
+    process = ChildProcess.build("bundle", "install", "--binstubs", tempdir.path)
+    process.io.inherit!
+    process.start
+    process.poll_for_exit(64000)
+    if process.exit_code != 0
+      # Bundle install failed...
+      puts "Bundle install failed!"
+      abort
+    end
+
+    # Generate the actual configuration
+    config = {
+      "vagrant_path" => File.join(tempdir.path, "vagrant"),
+      "vagrant_version" => Vagrant::VERSION,
+      "env" => {
+        "BUNDLE_GEMFILE" => File.expand_path("../../Gemfile", __FILE__)
+      },
+      "box_directory" => box_dir.to_s
+    }
+
+    File.open("acceptance_config.yml", "w+") do |f|
+      f.write(YAML.dump(config))
+    end
+
+    puts <<-OUTPUT
+Acceptance test configuration is now in this directory in
+"acceptance_config.yml." Set your ACCEPTANCE_CONFIG environmental
+variable to this file and run any of the acceptance tests now.
+OUTPUT
+  end
+end

data/tasks/bundler.rake

@@ -0,0 +1,3 @@
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks

data/tasks/test.rake

@@ -0,0 +1,20 @@
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+namespace :test do
+  RSpec::Core::RakeTask.new do |t|
+    t.name = "unit"
+    t.pattern = "test/unit/**/*_test.rb"
+  end
+
+  Rake::TestTask.new do |t|
+    t.name = "unit_old"
+    t.libs << "test/unit_legacy"
+    t.pattern = "test/unit_legacy/**/*_test.rb"
+  end
+
+  RSpec::Core::RakeTask.new do |t|
+    t.name = "acceptance"
+    t.pattern = "test/acceptance/**/*_test.rb"
+  end
+end

data/templates/commands/init/Vagrantfile.erb

@@ -0,0 +1,111 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+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.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "<%= box_name %>"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # 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" %>"
+
+  # 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
+
+  # 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"
+
+  # 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
+  # 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.
+  # You will need to create the manifests directory and a manifest in
+  # the file <%= box_name %>.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "init.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # 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
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/templates/commands/ssh_config/config.erb

@@ -0,0 +1,16 @@
+Host <%= host_key %>
+  HostName <%= ssh_host %>
+  User <%= ssh_user %>
+  Port <%= ssh_port %>
+  UserKnownHostsFile /dev/null
+  StrictHostKeyChecking no
+  PasswordAuthentication no
+  IdentityFile "<%= private_key_path %>"
+  IdentitiesOnly yes
+  LogLevel FATAL
+<% if forward_agent -%>
+  ForwardAgent yes
+<% end -%>
+<% if forward_x11 -%>
+  ForwardX11 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 -%>

data/templates/config/validation_failed.erb

@@ -0,0 +1,7 @@
+<% errors.each do |section, list| -%>
+<%= section %>:
+<% list.each do |error| -%>
+* <%= error %>
+<% end -%>
+
+<% end -%>

data/templates/guests/arch/network_dhcp.erb

@@ -0,0 +1,4 @@
+CONNECTION='ethernet'
+DESCRIPTION='A basic dhcp ethernet connection'
+INTERFACE='eth<%= options[:interface] %>'
+IP='dhcp'

data/templates/guests/arch/network_static.erb

@@ -0,0 +1,6 @@
+CONNECTION='ethernet'
+DESCRIPTION='A basic static ethernet connection'
+INTERFACE='eth<%= options[:interface] %>'
+IP='static'
+ADDR='<%= options[:ip]%>'
+NETMASK='<%= options[:netmask] %>'

data/templates/guests/debian/network_dhcp.erb

@@ -0,0 +1,11 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+auto eth<%= options[:interface] %>
+iface eth<%= options[:interface] %> inet dhcp
+<% if !options[:use_dhcp_assigned_default_route] %>
+    post-up route del default dev $IFACE
+<% else %>
+    # needed as some newer distribution do not properly load routes, ubuntu 12.04
+    post-up dhclient $IFACE
+<% end %>
+#VAGRANT-END

data/templates/guests/debian/network_static.erb

@@ -0,0 +1,7 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+auto eth<%= options[:interface] %>
+iface eth<%= options[:interface] %> inet static
+      address <%= options[:ip] %>
+      netmask <%= options[:netmask] %>
+#VAGRANT-END

data/templates/guests/fedora/network_dhcp.erb

@@ -0,0 +1,6 @@
+#VAGRANT-BEGIN
+# The contents below are automatically generated by Vagrant. Do not modify.
+BOOTPROTO=dhcp
+ONBOOT=yes
+DEVICE=p7p<%= options[:interface] %>
+#VAGRANT-END