vagrant-lxc 0.0.1 → 0.0.2

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

@@ -1,16 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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