vagrant-lxc 0.0.1

data/vendor/vagrant/plugins/provisioners/puppet/config/puppet_server.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Puppet
+    module Config
+      class PuppetServer < Vagrant.plugin("2", :config)
+        attr_accessor :puppet_server
+        attr_accessor :puppet_node
+        attr_accessor :options
+        attr_accessor :facter
+
+        def facter; @facter ||= {}; end
+        def puppet_server; @puppet_server || "puppet"; end
+        def options; @options ||= []; end
+      end
+    end
+  end
+end

data/vendor/vagrant/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/vendor/vagrant/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/vendor/vagrant/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/vendor/vagrant/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/vendor/vagrant/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/vendor/vagrant/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/vendor/vagrant/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