vagrant-lxc 0.0.1 → 0.0.2

data/vendor/vagrant/plugins/providers/virtualbox/action/package.rb

@@ -1,20 +0,0 @@
-require 'vagrant/action/general/package'
-
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class Package < Vagrant::Action::General::Package
-        # Doing this so that we can test that the parent is properly
-        # called in the unit tests.
-        alias_method :general_call, :call
-        def call(env)
-          # Just match up a couple environmental variables so that
-          # the superclass will do the right thing. Then, call the
-          # superclass
-          env["package.directory"] = env["export.temp_dir"]
-          general_call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/package_vagrantfile.rb

@@ -1,33 +0,0 @@
-require 'vagrant/util/template_renderer'
-
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class PackageVagrantfile
-        # For TemplateRenderer
-        include Vagrant::Util
-
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          @env = env
-          create_vagrantfile
-          @app.call(env)
-        end
-
-        # This method creates the auto-generated Vagrantfile at the root of the
-        # box. This Vagrantfile contains the MAC address so that the user doesn't
-        # have to worry about it.
-        def create_vagrantfile
-          File.open(File.join(@env["export.temp_dir"], "Vagrantfile"), "w") do |f|
-            f.write(TemplateRenderer.render("package_Vagrantfile", {
-              :base_mac => @env[:machine].provider.driver.read_mac_address
-            }))
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/prepare_forwarded_port_collision_params.rb

@@ -1,35 +0,0 @@
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class PrepareForwardedPortCollisionParams
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          # Get the forwarded ports used by other virtual machines and
-          # consider those in use as well.
-          env[:port_collision_extra_in_use] = env[:machine].provider.driver.read_used_ports
-
-          # Build the remap for any existing collision detections
-          remap = {}
-          env[:port_collision_remap] = remap
-          env[:machine].provider.driver.read_forwarded_ports.each do |_nic, name, hostport, _guestport|
-            env[:machine].config.vm.networks.each do |type, options|
-              next if type != :forwarded_port
-
-              # If the ID matches the name of the forwarded port, then
-              # remap.
-              if options[:id] == name
-                remap[name] = hostport
-                break
-              end
-            end
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/prepare_nfs_settings.rb

@@ -1,51 +0,0 @@
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class PrepareNFSSettings
-        def initialize(app,env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
-        end
-
-        def call(env)
-          @app.call(env)
-
-          env[:nfs_host_ip]    = read_host_ip(env[:machine])
-          env[:nfs_machine_ip] = read_machine_ip(env[:machine])
-        end
-
-        # Returns the IP address of the first host only network adapter
-        #
-        # @param [Machine] machine
-        # @return [String]
-        def read_host_ip(machine)
-          machine.provider.driver.read_network_interfaces.each do |adapter, opts|
-            if opts[:type] == :hostonly
-              machine.provider.driver.read_host_only_interfaces.each do |interface|
-                if interface[:name] == opts[:hostonly]
-                  return interface[:ip]
-                end
-              end
-            end
-          end
-
-          nil
-        end
-
-        # Returns the IP address of the guest by looking at the first
-        # enabled host only network.
-        #
-        # @return [String]
-        def read_machine_ip(machine)
-          machine.config.vm.networks.each do |type, options|
-            if type == :private_network && options[:ip].is_a?(String)
-              return options[:ip]
-            end
-          end
-
-          nil
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/prune_nfs_exports.rb

@@ -1,20 +0,0 @@
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class PruneNFSExports
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          if env[:host]
-            vms = env[:machine].provider.driver.read_vms
-            env[:host].nfs_prune(vms.values)
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/resume.rb

@@ -1,25 +0,0 @@
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class Resume
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          current_state = env[:machine].provider.state.id
-
-          if current_state == :paused
-            env[:ui].info I18n.t("vagrant.actions.vm.resume.unpausing")
-            env[:machine].provider.driver.resume
-          elsif current_state == :saved
-            env[:ui].info I18n.t("vagrant.actions.vm.resume.resuming")
-            env[:action_runner].run(Boot, env)
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/sane_defaults.rb

@@ -1,87 +0,0 @@
-require "log4r"
-
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class SaneDefaults
-        def initialize(app, env)
-          @logger = Log4r::Logger.new("vagrant::action::vm::sanedefaults")
-          @app = app
-        end
-
-        def call(env)
-          # Set the env on an instance variable so we can access it in
-          # helpers.
-          @env = env
-
-          # Enable the host IO cache on the sata controller. Note that
-          # if this fails then its not a big deal, so we don't raise any
-          # errors. The Host IO cache vastly improves disk IO performance
-          # for VMs.
-          command = [
-            "storagectl", env[:machine].id,
-            "--name", "SATA Controller",
-            "--hostiocache", "on"
-          ]
-          attempt_and_log(command, "Enabling the Host I/O cache on the SATA controller...")
-
-          if env[:machine].provider_config.auto_nat_dns_proxy
-            @logger.info("Automatically figuring out whether to enable/disable NAT DNS proxy...")
-
-            # Enable/disable the NAT DNS proxy as necessary
-            if enable_dns_proxy?
-              command = ["modifyvm", env[:machine].id, "--natdnsproxy1", "on"]
-              attempt_and_log(command, "Enable the NAT DNS proxy on adapter 1...")
-            else
-              command = [ "modifyvm", env[:machine].id, "--natdnsproxy1", "off" ]
-              attempt_and_log(command, "Disable the NAT DNS proxy on adapter 1...")
-              command = [ "modifyvm", env[:machine].id, "--natdnshostresolver1", "off" ]
-              attempt_and_log(command, "Disable the NAT DNS resolver on adapter 1...")
-            end
-          else
-            @logger.info("NOT trying to automatically manage NAT DNS proxy.")
-          end
-
-          @app.call(env)
-        end
-
-        protected
-
-        # This is just a helper method that executes a single command, logs
-        # the given string to the log, and also includes the exit status in
-        # the log message.
-        #
-        # @param [Array] command Command to run
-        # @param [String] log Log message to write.
-        def attempt_and_log(command, log)
-          result = @env[:machine].provider.driver.execute_command(command)
-          @logger.info("#{log} (exit status = #{result.exit_code})")
-        end
-
-        # This uses some heuristics to determine if the NAT DNS proxy should
-        # be enabled or disabled. See the comments within the function body
-        # itself to see the checks it does.
-        #
-        # @return [Boolean]
-        def enable_dns_proxy?
-          begin
-            contents = File.read("/etc/resolv.conf")
-
-            if contents =~ /^nameserver 127\.0\.(0|1)\.1$/
-              # The use of both natdnsproxy and natdnshostresolver break on
-              # Ubuntu 12.04 and 12.10 that uses resolvconf with localhost. When used
-              # VirtualBox will give the client dns server 10.0.2.3, while
-              # not binding to that address itself. Therefore disable this
-              # feature if host uses the resolvconf server 127.0.0.1 or
-              # 127.0.1.1
-              @logger.info("Disabling DNS proxy since resolv.conf contains 127.0.0.1 or 127.0.1.1")
-              return false
-            end
-          rescue Errno::ENOENT; end
-
-          return true
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/set_name.rb

@@ -1,40 +0,0 @@
-require "log4r"
-
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class SetName
-        def initialize(app, env)
-          @logger = Log4r::Logger.new("vagrant::action::vm::setname")
-          @app = app
-        end
-
-        def call(env)
-          name = env[:machine].provider_config.name
-
-          # If no name was manually set, then use a default
-          if !name
-            prefix = env[:root_path].basename.to_s
-            prefix.gsub!(/[^-a-z0-9_]/i, "")
-            name = prefix + "_#{Time.now.to_i}"
-          end
-
-          # Verify the name is not taken
-          vms = env[:machine].provider.driver.read_vms
-          raise Vagrant::Errors::VMNameExists, :name => name if \
-            vms.has_key?(name) && vms[name] != env[:machine].id
-
-          if vms.has_key?(name)
-            @logger.info("Not setting the name because our name is already set.")
-          else
-            @logger.info("Setting the name of the VM: #{name}")
-            env[:ui].info(I18n.t("vagrant.actions.vm.set_name.setting_name"))
-            env[:machine].provider.driver.set_name(name)
-          end
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/setup_package_files.rb

@@ -1,51 +0,0 @@
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class SetupPackageFiles
-        def initialize(app, env)
-          @app = app
-
-          env["package.include"] ||= []
-          env["package.vagrantfile"] ||= nil
-        end
-
-        def call(env)
-          files = {}
-          env["package.include"].each do |file|
-            source = Pathname.new(file)
-            dest   = nil
-
-            # If the source is relative then we add the file as-is to the include
-            # directory. Otherwise, we copy only the file into the root of the
-            # include directory. Kind of strange, but seems to match what people
-            # expect based on history.
-            if source.relative?
-              dest = source
-            else
-              dest = source.basename
-            end
-
-            # Assign the mapping
-            files[file] = dest
-          end
-
-          if env["package.vagrantfile"]
-            # Vagrantfiles are treated special and mapped to a specific file
-            files[env["package.vagrantfile"]] = "_Vagrantfile"
-          end
-
-          # Verify the mapping
-          files.each do |from, _|
-            raise Vagrant::Errors::PackageIncludeMissing,
-              :file => from if !File.exist?(from)
-          end
-
-          # Save the mapping
-          env["package.files"] = files
-
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/providers/virtualbox/action/share_folders.rb

@@ -1,113 +0,0 @@
-require "pathname"
-
-require "log4r"
-
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class ShareFolders
-        def initialize(app, env)
-          @logger = Log4r::Logger.new("vagrant::action::vm::share_folders")
-          @app    = app
-        end
-
-        def call(env)
-          @env = env
-
-          prepare_folders
-          create_metadata
-
-          @app.call(env)
-
-          mount_shared_folders
-        end
-
-        # This method returns an actual list of VirtualBox shared
-        # folders to create and their proper path.
-        def shared_folders
-          {}.tap do |result|
-            @env[:machine].config.vm.synced_folders.each do |id, data|
-              # Ignore NFS shared folders
-              next if data[:nfs]
-
-              # This to prevent overwriting the actual shared folders data
-              result[id] = data.dup
-            end
-          end
-        end
-
-        # Prepares the shared folders by verifying they exist and creating them
-        # if they don't.
-        def prepare_folders
-          shared_folders.each do |id, options|
-            hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
-
-            if !hostpath.directory? && options[:create]
-              # Host path doesn't exist, so let's create it.
-              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
-
-              begin
-                hostpath.mkpath
-              rescue Errno::EACCES
-                raise Vagrant::Errors::SharedFolderCreateFailed,
-                  :path => hostpath.to_s
-              end
-            end
-          end
-        end
-
-        def create_metadata
-          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
-
-          folders = []
-          shared_folders.each do |id, data|
-            folders << {
-              :name => id,
-              :hostpath => File.expand_path(data[:hostpath], @env[:root_path]),
-              :transient => data[:transient]
-            }
-          end
-
-          @env[:machine].provider.driver.share_folders(folders)
-        end
-
-        def mount_shared_folders
-          @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
-
-          # short guestpaths first, so we don't step on ourselves
-          folders = shared_folders.sort_by do |id, data|
-            if data[:guestpath]
-              data[:guestpath].length
-            else
-              # A long enough path to just do this at the end.
-              10000
-            end
-          end
-
-          # Go through each folder and mount
-          folders.each do |id, data|
-            if data[:guestpath]
-              # Guest path specified, so mount the folder to specified point
-              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
-                                    :guest_path => data[:guestpath]))
-
-              # Dup the data so we can pass it to the guest API
-              data = data.dup
-
-              # Calculate the owner and group
-              data[:owner] ||= @env[:machine].config.ssh.username
-              data[:group] ||= @env[:machine].config.ssh.username
-
-              # Mount the actual folder
-              @env[:machine].guest.mount_shared_folder(id, data[:guestpath], data)
-            else
-              # If no guest path is specified, then automounting is disabled
-              @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
-                                    :host_path => data[:hostpath]))
-            end
-          end
-        end
-      end
-    end
-  end
-end