vagrant-lxc 0.0.1 → 0.0.2

data/vendor/vagrant/lib/vagrant/action/builtin/lock.rb

@@ -1,57 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class creates a multi-process lock using `flock`. The lock
-      # is active for the remainder of the middleware stack.
-      class Lock
-        def initialize(app, env, options=nil)
-          @app     = app
-          @logger  = Log4r::Logger.new("vagrant::action::builtin::lock")
-          @options ||= options || {}
-          raise ArgumentError, "Please specify a lock path" if !@options[:path]
-          raise ArgumentError, "Please specify an exception." if !@options[:exception]
-        end
-
-        def call(env)
-          lock_path = @options[:path]
-          lock_path = lock_path.call(env) if lock_path.is_a?(Proc)
-
-          env_key   = "has_lock_#{lock_path}"
-
-          if !env[env_key]
-            # If we already have the key in our environment we assume the
-            # lock is held by our middleware stack already and we allow
-            # nesting.
-            File.open(lock_path, "w+") do |f|
-              # The file locking fails only if it returns "false." If it
-              # succeeds it returns a 0, so we must explicitly check for
-              # the proper error case.
-              @logger.info("Locking: #{lock_path}")
-              if f.flock(File::LOCK_EX | File::LOCK_NB) === false
-                exception = @options[:exception]
-                exception = exception.call(env) if exception.is_a?(Proc)
-                raise exception
-              end
-
-              # Set that we gained the lock and call deeper into the
-              # middleware, but make sure we UNSET the lock when we leave.
-              begin
-                env[env_key] = true
-                @app.call(env)
-              ensure
-                @logger.info("Unlocking: #{lock_path}")
-                env[env_key] = false
-                f.flock(File::LOCK_UN)
-              end
-            end
-          else
-            # Just call up the middleware because we already hold the lock
-            @app.call(env)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/action/builtin/nfs.rb

@@ -1,117 +0,0 @@
-require 'digest/md5'
-require 'fileutils'
-require 'pathname'
-
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This built-in middleware exports and mounts NFS shared folders.
-      #
-      # To use this middleware, two configuration parameters must be given
-      # via the environment hash:
-      #
-      #   - `:nfs_host_ip` - The IP of where to mount the NFS folder from.
-      #   - `:nfs_machine_ip` - The IP of the machine where the NFS folder
-      #     will be mounted.
-      #
-      class NFS
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::nfs")
-        end
-
-        def call(env)
-          # We forward things along first. We do everything on the tail
-          # end of the middleware call.
-          @app.call(env)
-
-          # Used by prepare_permission, so we need to save it
-          @env = env
-
-          folders = {}
-          env[:machine].config.vm.synced_folders.each do |id, opts|
-            # If this synced folder doesn't enable NFS, ignore it.
-            next if !opts[:nfs]
-
-            # Expand the host path, create it if we have to and
-            # store away the folder.
-            hostpath = Pathname.new(opts[:hostpath]).expand_path(env[:root_path])
-
-            if !hostpath.directory? && opts[:create]
-              # Host path doesn't exist, so let's create it.
-              @logger.debug("Host path doesn't exist, creating: #{hostpath}")
-
-              begin
-                FileUtils.mkpath(hostpath)
-              rescue Errno::EACCES
-                raise Vagrant::Errors::SharedFolderCreateFailed,
-                  :path => hostpath.to_s
-              end
-            end
-
-            # Set the hostpath back on the options and save it
-            opts[:hostpath] = hostpath.to_s
-            folders[id] = opts
-          end
-
-          if !folders.empty?
-            raise Errors::NFSNoHostIP if !env[:nfs_host_ip]
-            raise Errors::NFSNoGuestIP if !env[:nfs_machine_ip]
-
-            # Prepare the folder, this means setting up various options
-            # and such on the folder itself.
-            folders.each { |id, opts| prepare_folder(opts) }
-
-            # Export the folders
-            env[:ui].info I18n.t("vagrant.actions.vm.nfs.exporting")
-            env[:host].nfs_export(env[:machine].id, env[:nfs_machine_ip], folders)
-
-            # Mount
-            env[:ui].info I18n.t("vagrant.actions.vm.nfs.mounting")
-
-            # Only mount folders that have a guest path specified.
-            mount_folders = {}
-            folders.each do |id, opts|
-              mount_folders[id] = opts.dup if opts[:guestpath]
-            end
-
-            # Mount them!
-            env[:machine].guest.mount_nfs(env[:nfs_host_ip], mount_folders)
-          end
-        end
-
-        protected
-
-        def prepare_folder(opts)
-          opts[:map_uid] = prepare_permission(:uid, opts)
-          opts[:map_gid] = prepare_permission(:gid, opts)
-          opts[:nfs_version] ||= 3
-
-          # The poor man's UUID. An MD5 hash here is sufficient since
-          # we need a 32 character "uuid" to represent the filesystem
-          # of an export. Hashing the host path is safe because two of
-          # the same host path will hash to the same fsid.
-          opts[:uuid]    = Digest::MD5.hexdigest(opts[:hostpath])
-        end
-
-        # Prepares the UID/GID settings for a single folder.
-        def prepare_permission(perm, opts)
-          key = "map_#{perm}".to_sym
-          return nil if opts.has_key?(key) && opts[key].nil?
-
-          # The options on the hash get priority, then the default
-          # values
-          value = opts.has_key?(key) ? opts[key] : @env[:machine].config.nfs.send(key)
-          return value if value != :auto
-
-          # Get UID/GID from folder if we've made it this far
-          # (value == :auto)
-          stat = File.stat(opts[:hostpath])
-          return stat.send(perm)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/action/builtin/provision.rb

@@ -1,70 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class will run the configured provisioners against the
-      # machine.
-      #
-      # This action should be placed BEFORE the machine is booted so it
-      # can do some setup, and then run again (on the return path) against
-      # a running machine.
-      class Provision
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::provision")
-        end
-
-        def call(env)
-          # Check if we're even provisioning things.
-          enabled = true
-          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
-
-          # This keeps track of a mapping between provisioner and type
-          type_map = {}
-
-          # Get all the configured provisioners
-          provisioners = env[:machine].config.vm.provisioners.map do |provisioner|
-            # Instantiate the provisioner
-            klass  = Vagrant.plugin("2").manager.provisioners[provisioner.name]
-            result = klass.new(env[:machine], provisioner.config)
-
-            # Store in the type map so that --provision-with works properly
-            type_map[result] = provisioner.name
-
-            # Return the result
-            result
-          end
-
-          # Ask the provisioners to modify the configuration if needed
-          provisioners.each do |p|
-            p.configure(env[:machine].config)
-          end
-
-          # Continue, we need the VM to be booted.
-          @app.call(env)
-
-          # Actually provision if we enabled it
-          if enabled
-            provisioners.each do |p|
-              next if env[:provision_types] && \
-                !env[:provision_types].include?(type_map[p])
-
-              run_provisioner(env, p)
-            end
-          end
-        end
-
-        # This is pulled out into a seperate method so that users can
-        # subclass and implement custom behavior if they'd like around
-        # this step.
-        def run_provisioner(env, p)
-          env[:ui].info(I18n.t("vagrant.actions.vm.provision.beginning",
-                               :provisioner => p.class))
-
-          p.provision
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/action/builtin/set_hostname.rb

@@ -1,27 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This middleware sets the hostname of the guest according to the
-      # "vm.hostname" configuration parameter if it is set. This middleware
-      # should be placed such that the after the @app.call, a booted machine
-      # is available (this generally means BEFORE the boot middleware).
-      class SetHostname
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          @app.call(env)
-
-          hostname = env[:machine].config.vm.hostname
-          if !hostname.nil?
-            env[:ui].info I18n.t("vagrant.actions.vm.hostname.setting")
-            env[:machine].guest.change_host_name(hostname)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/action/builtin/ssh_exec.rb

@@ -1,42 +0,0 @@
-require "pathname"
-
-require "vagrant/util/ssh"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class will exec into a full fledged SSH console into the
-      # remote machine. This middleware assumes that the VM is running and
-      # ready for SSH, and uses the {Machine#ssh_info} method to retrieve
-      # SSH information necessary to connect.
-      #
-      # Note: If there are any middleware after `SSHExec`, they will **not**
-      # run, since exec replaces the currently running process.
-      class SSHExec
-        # For quick access to the `SSH` class.
-        include Vagrant::Util
-
-        def initialize(app, env)
-          @app = app
-        end
-
-        def call(env)
-          # Grab the SSH info from the machine
-          info = env[:machine].ssh_info
-
-          # If the result is nil, then the machine is telling us that it is
-          # not yet ready for SSH, so we raise this exception.
-          raise Errors::SSHNotReady if info.nil?
-
-          if info[:private_key_path]
-            # Check the SSH key permissions
-            SSH.check_key_permissions(Pathname.new(info[:private_key_path]))
-          end
-
-          # Exec!
-          SSH.exec(info, env[:ssh_opts])
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/action/builtin/ssh_run.rb

@@ -1,43 +0,0 @@
-require "log4r"
-
-module Vagrant
-  module Action
-    module Builtin
-      # This class will run a single command on the remote machine and will
-      # mirror the output to the UI. The resulting exit status of the command
-      # will exist in the `:ssh_run_exit_status` key in the environment.
-      class SSHRun
-        def initialize(app, env)
-          @app    = app
-          @logger = Log4r::Logger.new("vagrant::action::builtin::ssh_run")
-        end
-
-        def call(env)
-          command = env[:ssh_run_command]
-
-          @logger.debug("Executing command: #{command}")
-          exit_status = 0
-          exit_status = env[:machine].communicate.execute(command, :error_check => false) do |type, data|
-            # Determine the proper channel to send the output onto depending
-            # on the type of data we are receiving.
-            channel = type == :stdout ? :out : :error
-
-            # Print the output as it comes in, but don't prefix it and don't
-            # force a new line so that the output is properly preserved however
-            # it may be formatted.
-            env[:ui].info(data.to_s,
-                          :prefix => false,
-                          :new_line => false,
-                          :channel => channel)
-          end
-
-          # Set the exit status on a known environmental variable
-          env[:ssh_run_exit_status] = exit_status
-
-          # Call the next middleware
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/lib/vagrant/action/general/package.rb

@@ -1,102 +0,0 @@
-require 'fileutils'
-
-require 'vagrant/util/subprocess'
-
-module Vagrant
-  module Action
-    module General
-      # A general packaging (tar) middleware. Given the following options,
-      # it will do the right thing:
-      #
-      #   * package.output - The filename of the outputted package.
-      #   * package.include - An array of files to include in the package.
-      #   * package.directory - The directory which contains the contents to
-      #       compress into the package.
-      #
-      # This middleware always produces the final file in the current working
-      # directory (FileUtils.pwd)
-      class Package
-        include Util
-
-        def initialize(app, env)
-          @app = app
-
-          env["package.files"]  ||= {}
-          env["package.output"] ||= env["global_config"].package.name
-        end
-
-        def call(env)
-          @env = env
-
-          raise Errors::PackageOutputDirectory if File.directory?(tar_path)
-          raise Errors::PackageOutputExists if File.exist?(tar_path)
-          raise Errors::PackageRequiresDirectory if !env["package.directory"] ||
-            !File.directory?(env["package.directory"])
-
-          compress
-
-          @app.call(env)
-        end
-
-        def recover(env)
-          # There are certain exceptions that we don't delete the file for.
-          ignore_exc = [Errors::PackageOutputDirectory, Errors::PackageOutputExists]
-          ignore_exc.each do |exc|
-            return if env["vagrant.error"].is_a?(exc)
-          end
-
-          # Cleanup any packaged files if the packaging failed at some point.
-          File.delete(tar_path) if File.exist?(tar_path)
-        end
-
-        # This method copies the include files (passed in via command line)
-        # to the temporary directory so they are included in a sub-folder within
-        # the actual box
-        def copy_include_files
-          include_directory = Pathname.new(@env["package.directory"]).join("include")
-
-          @env["package.files"].each do |from, dest|
-            # We place the file in the include directory
-            to = include_directory.join(dest)
-
-            @env[:ui].info I18n.t("vagrant.actions.general.package.packaging", :file => from)
-            FileUtils.mkdir_p(to.parent)
-
-            # Copy direcotry contents recursively.
-            if File.directory?(from)
-              FileUtils.cp_r(Dir.glob(from), to.parent, :preserve => true)
-            else
-              FileUtils.cp(from, to, :preserve => true)
-            end
-          end
-        end
-
-        # Compress the exported file into a package
-        def compress
-          @env[:ui].info I18n.t("vagrant.actions.general.package.compressing", :tar_path => tar_path)
-
-          # Copy over the included files
-          copy_include_files
-
-          # Get the output path. We have to do this up here so that the
-          # pwd returns the proper thing.
-          output_path = tar_path.to_s
-
-          # Switch into that directory and package everything up
-          Dir.chdir(@env["package.directory"]) do
-            # Find all the files in our current directory and tar it up!
-            files = Dir.glob(File.join(".", "**", "*"))
-
-            # Package!
-            Util::Subprocess.execute("bsdtar", "-czf", output_path, *files)
-          end
-        end
-
-        # Path to the final box output file
-        def tar_path
-          File.expand_path(@env["package.output"], FileUtils.pwd)
-        end
-      end
-    end
-  end
-end