vagrant-lxc 0.0.1 → 0.0.2

data/vendor/vagrant/plugins/commands/ssh/plugin.rb

@@ -1,17 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandSSH
-    class Plugin < Vagrant.plugin("2")
-      name "ssh command"
-      description <<-DESC
-      The `ssh` command allows you to SSH in to your running virtual machine.
-      DESC
-
-      command("ssh") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/ssh_config/command.rb

@@ -1,49 +0,0 @@
-require 'optparse'
-
-require "vagrant/util/safe_puts"
-
-module VagrantPlugins
-  module CommandSSHConfig
-    class Command < Vagrant.plugin("2", :command)
-      include Vagrant::Util::SafePuts
-
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant ssh-config [vm-name] [--host name]"
-          o.separator ""
-
-          o.on("--host COMMAND", "Name the host for the config..") do |h|
-            options[:host] = h
-          end
-        end
-
-        argv = parse_options(opts)
-        return if !argv
-
-        with_target_vms(argv, :single_target => true) do |machine|
-          ssh_info = machine.ssh_info
-          raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
-
-          variables = {
-            :host_key => options[:host] || machine.name || "vagrant",
-            :ssh_host => ssh_info[:host],
-            :ssh_port => ssh_info[:port],
-            :ssh_user => ssh_info[:username],
-            :private_key_path => ssh_info[:private_key_path],
-            :forward_agent => ssh_info[:forward_agent],
-            :forward_x11   => ssh_info[:forward_x11]
-          }
-
-          # Render the template and output directly to STDOUT
-          template = "commands/ssh_config/config"
-          safe_puts(Vagrant::Util::TemplateRenderer.render(template, variables))
-        end
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/ssh_config/plugin.rb

@@ -1,18 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandSSHConfig
-    class Plugin < Vagrant.plugin("2")
-      name "ssh-config command"
-      description <<-DESC
-      The `ssh-config` command dumps an OpenSSH compatible configuration
-      that can be used to quickly SSH into your virtual machine.
-      DESC
-
-      command("ssh-config") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/status/command.rb

@@ -1,39 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandStatus
-    class Command < Vagrant.plugin("2", :command)
-      def execute
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant status [machine-name]"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        state = nil
-        results = []
-        with_target_vms(argv) do |machine|
-          state = machine.state if !state
-          results << "#{machine.name.to_s.ljust(25)}#{machine.state.short_description} (#{machine.provider_name})"
-        end
-
-        message = nil
-        if results.length == 1
-          message = state.long_description
-        else
-          message = I18n.t("vagrant.commands.status.listing")
-        end
-
-        @env.ui.info(I18n.t("vagrant.commands.status.output",
-                            :states => results.join("\n"),
-                            :message => message),
-                     :prefix => false)
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/status/plugin.rb

@@ -1,18 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandStatus
-    class Plugin < Vagrant.plugin("2")
-      name "status command"
-      description <<-DESC
-      The `status` command shows what the running state (running/saved/..)
-      is of all your virtual machines in this environment.
-      DESC
-
-      command("status") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/suspend/command.rb

@@ -1,25 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandSuspend
-    class Command < Vagrant.plugin("2", :command)
-      def execute
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant suspend [vm-name]"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        @logger.debug("'suspend' each target VM...")
-        with_target_vms(argv) do |vm|
-          vm.action(:suspend)
-        end
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/suspend/plugin.rb

@@ -1,18 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandSuspend
-    class Plugin < Vagrant.plugin("2")
-      name "suspend command"
-      description <<-DESC
-      The `suspend` command suspends execution and puts it to sleep.
-      The command `resume` returns it to running status.
-      DESC
-
-      command("suspend") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/up/command.rb

@@ -1,45 +0,0 @@
-require 'optparse'
-
-require "vagrant"
-
-require File.expand_path("../start_mixins", __FILE__)
-
-module VagrantPlugins
-  module CommandUp
-    class Command < Vagrant.plugin("2", :command)
-      include StartMixins
-
-      def execute
-        options = {}
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant up [vm-name] [--[no-]provision] [--provider provider] [-h]"
-          o.separator ""
-
-          build_start_options(o, options)
-
-          o.on("--provider provider", String,
-               "Back the machine with a specific provider.") do |provider|
-            options[:provider] = provider
-          end
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        # Go over each VM and bring it up
-        @logger.debug("'Up' each target VM...")
-        with_target_vms(argv, :provider => options[:provider]) do |machine|
-          @env.ui.info(I18n.t(
-            "vagrant.commands.up.upping",
-            :name => machine.name,
-            :provider => machine.provider_name))
-          machine.action(:up, options)
-        end
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/up/plugin.rb

@@ -1,17 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandUp
-    class Plugin < Vagrant.plugin("2")
-      name "up command"
-      description <<-DESC
-      The `up` command brings the virtual environment up and running.
-      DESC
-
-      command("up") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/commands/up/start_mixins.rb

@@ -1,26 +0,0 @@
-module VagrantPlugins
-  module CommandUp
-    module StartMixins
-      # This adds the standard `start` command line flags to the given
-      # OptionParser, storing the result in the `options` dictionary.
-      #
-      # @param [OptionParser] parser
-      # @param [Hash] options
-      def build_start_options(parser, options)
-        # Setup the defaults
-        options[:provision_enabled] = true
-        options[:provision_types] = nil
-
-        # Add the options
-        parser.on("--[no-]provision", "Enable or disable provisioning") do |p|
-          options[:provision_enabled] = p
-        end
-
-        parser.on("--provision-with x,y,z", Array,
-                "Enable only certain provisioners, by type.") do |list|
-          options[:provision_types] = list.map { |type| type.to_sym }
-        end
-      end
-    end
-  end
-end

data/vendor/vagrant/plugins/communicators/ssh/communicator.rb

@@ -1,317 +0,0 @@
-require 'logger'
-require 'pathname'
-require 'stringio'
-require 'timeout'
-
-require 'log4r'
-require 'net/ssh'
-require 'net/scp'
-
-require 'vagrant/util/ansi_escape_code_remover'
-require 'vagrant/util/file_mode'
-require 'vagrant/util/platform'
-require 'vagrant/util/retryable'
-require 'vagrant/util/ssh'
-
-module VagrantPlugins
-  module CommunicatorSSH
-    # This class provides communication with the VM via SSH.
-    class Communicator < Vagrant.plugin("2", :communicator)
-      include Vagrant::Util::ANSIEscapeCodeRemover
-      include Vagrant::Util::Retryable
-
-      def self.match?(machine)
-        # All machines are currently expected to have SSH.
-        true
-      end
-
-      def initialize(machine)
-        @machine = machine
-        @logger  = Log4r::Logger.new("vagrant::communication::ssh")
-        @connection = nil
-      end
-
-      def ready?
-        @logger.debug("Checking whether SSH is ready...")
-
-        # Attempt to connect. This will raise an exception if it fails.
-        connect
-
-        # If we reached this point then we successfully connected
-        @logger.info("SSH is ready!")
-        true
-      rescue Vagrant::Errors::VagrantError => e
-        # We catch a `VagrantError` which would signal that something went
-        # wrong expectedly in the `connect`, which means we didn't connect.
-        @logger.info("SSH not up: #{e.inspect}")
-        return false
-      end
-
-      def execute(command, opts=nil, &block)
-        opts = {
-          :error_check => true,
-          :error_class => Vagrant::Errors::VagrantError,
-          :error_key   => :ssh_bad_exit_status,
-          :command     => command,
-          :sudo        => false
-        }.merge(opts || {})
-
-        # Connect via SSH and execute the command in the shell.
-        exit_status = connect do |connection|
-          shell_execute(connection, command, opts[:sudo], &block)
-        end
-
-        # Check for any errors
-        if opts[:error_check] && exit_status != 0
-          # The error classes expect the translation key to be _key,
-          # but that makes for an ugly configuration parameter, so we
-          # set it here from `error_key`
-          error_opts = opts.merge(:_key => opts[:error_key])
-          raise opts[:error_class], error_opts
-        end
-
-        # Return the exit status
-        exit_status
-      end
-
-      def sudo(command, opts=nil, &block)
-        # Run `execute` but with the `sudo` option.
-        opts = { :sudo => true }.merge(opts || {})
-        execute(command, opts, &block)
-      end
-
-      def download(from, to=nil)
-        @logger.debug("Downloading: #{from} to #{to}")
-
-        scp_connect do |scp|
-          scp.download!(from, to)
-        end
-      end
-
-      def test(command, opts=nil)
-        opts = { :error_check => false }.merge(opts || {})
-        execute(command, opts) == 0
-      end
-
-      def upload(from, to)
-        @logger.debug("Uploading: #{from} to #{to}")
-
-        scp_connect do |scp|
-          if File.directory?(from)
-            # Recurisvely upload directories
-            scp.upload!(from, to, :recursive => true)
-          else
-            # Open file read only to fix issue [GH-1036]
-            scp.upload!(File.open(from, "r"), to)
-          end
-        end
-      rescue RuntimeError => e
-        # Net::SCP raises a runtime error for this so the only way we have
-        # to really catch this exception is to check the message to see if
-        # it is something we care about. If it isn't, we re-raise.
-        raise if e.message !~ /Permission denied/
-
-        # Otherwise, it is a permission denied, so let's raise a proper
-        # exception
-        raise Vagrant::Errors::SCPPermissionDenied, :path => from.to_s
-      end
-
-      protected
-
-      # Opens an SSH connection and yields it to a block.
-      def connect
-        if @connection && !@connection.closed?
-          # There is a chance that the socket is closed despite us checking
-          # 'closed?' above. To test this we need to send data through the
-          # socket.
-          begin
-            @connection.exec!("")
-          rescue IOError
-            @logger.info("Connection has been closed. Not re-using.")
-            @connection = nil
-          end
-
-          # If the @connection is still around, then it is valid,
-          # and we use it.
-          if @connection
-            @logger.debug("Re-using SSH connection.")
-            return yield @connection if block_given?
-            return
-          end
-        end
-
-        # Get the SSH info for the machine, raise an exception if the
-        # provider is saying that SSH is not ready.
-        ssh_info = @machine.ssh_info
-        raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
-
-        # Build the options we'll use to initiate the connection via Net::SSH
-        opts = {
-          :auth_methods          => ["none", "publickey", "hostbased", "password"],
-          :config                => false,
-          :forward_agent         => ssh_info[:forward_agent],
-          :keys                  => [ssh_info[:private_key_path]],
-          :keys_only             => true,
-          :paranoid              => false,
-          :port                  => ssh_info[:port],
-          :user_known_hosts_file => []
-        }
-
-        # Check that the private key permissions are valid
-        Vagrant::Util::SSH.check_key_permissions(Pathname.new(ssh_info[:private_key_path]))
-
-        # Connect to SSH, giving it a few tries
-        connection = nil
-        begin
-          # These are the exceptions that we retry because they represent
-          # errors that are generally fixed from a retry and don't
-          # necessarily represent immediate failure cases.
-          exceptions = [
-            Errno::EADDRINUSE,
-            Errno::ECONNREFUSED,
-            Errno::ECONNRESET,
-            Errno::EHOSTUNREACH,
-            Net::SSH::Disconnect,
-            Timeout::Error
-          ]
-
-          retries = @machine.config.ssh.max_tries
-          timeout = @machine.config.ssh.timeout
-
-          @logger.info("Attempting SSH. Retries: #{retries}. Timeout: #{timeout}")
-          connection = retryable(:tries => retries, :on => exceptions) do
-            Timeout.timeout(timeout) do
-              begin
-                # This logger will get the Net-SSH log data for us.
-                ssh_logger_io = StringIO.new
-                ssh_logger    = Logger.new(ssh_logger_io)
-
-                # Setup logging for connections
-                connect_opts = opts.merge({
-                  :logger  => ssh_logger,
-                  :verbose => :debug
-                })
-
-                @logger.info("Attempting to connect to SSH: #{ssh_info[:host]}:#{ssh_info[:port]}")
-                Net::SSH.start(ssh_info[:host], ssh_info[:username], connect_opts)
-              ensure
-                # Make sure we output the connection log
-                @logger.debug("== Net-SSH connection debug-level log START ==")
-                @logger.debug(ssh_logger_io.string)
-                @logger.debug("== Net-SSH connection debug-level log END ==")
-              end
-            end
-          end
-        rescue Errno::ETIMEDOUT, Timeout::Error
-          # This happens if we continued to timeout when attempting to connect.
-          raise Vagrant::Errors::SSHConnectionTimeout
-        rescue Net::SSH::AuthenticationFailed
-          # This happens if authentication failed. We wrap the error in our
-          # own exception.
-          raise Vagrant::Errors::SSHAuthenticationFailed
-        rescue Net::SSH::Disconnect
-          # This happens if the remote server unexpectedly closes the
-          # connection. This is usually raised when SSH is running on the
-          # other side but can't properly setup a connection. This is
-          # usually a server-side issue.
-          raise Vagrant::Errors::SSHDisconnected
-        rescue Errno::ECONNREFUSED
-          # This is raised if we failed to connect the max amount of times
-          raise Vagrant::Errors::SSHConnectionRefused
-        rescue Errno::ECONNRESET
-          # This is raised if we failed to connect the max number of times
-          # due to an ECONNRESET.
-          raise Vagrant::Errors::SSHConnectionReset
-        rescue Errno::EHOSTDOWN
-          # This is raised if we get an ICMP DestinationUnknown error.
-          raise Vagrant::Errors::SSHHostDown
-        rescue NotImplementedError
-          # This is raised if a private key type that Net-SSH doesn't support
-          # is used. Show a nicer error.
-          raise Vagrant::Errors::SSHKeyTypeNotSupported
-        end
-
-        @connection = connection
-
-        # This is hacky but actually helps with some issues where
-        # Net::SSH is simply not robust enough to handle... see
-        # issue #391, #455, etc.
-        sleep 4
-
-        # Yield the connection that is ready to be used and
-        # return the value of the block
-        return yield connection if block_given?
-      end
-
-      # Executes the command on an SSH connection within a login shell.
-      def shell_execute(connection, command, sudo=false)
-        @logger.info("Execute: #{command} (sudo=#{sudo.inspect})")
-        exit_status = nil
-
-        # Determine the shell to execute. If we are using `sudo` then we
-        # need to wrap the shell in a `sudo` call.
-        shell = @machine.config.ssh.shell
-        shell = "sudo -H #{shell}" if sudo
-
-        # Open the channel so we can execute or command
-        channel = connection.open_channel do |ch|
-          ch.exec(shell) do |ch2, _|
-            # Setup the channel callbacks so we can get data and exit status
-            ch2.on_data do |ch3, data|
-              # Filter out the clear screen command
-              data = remove_ansi_escape_codes(data)
-              @logger.debug("stdout: #{data}")
-              yield :stdout, data if block_given?
-            end
-
-            ch2.on_extended_data do |ch3, type, data|
-              # Filter out the clear screen command
-              data = remove_ansi_escape_codes(data)
-              @logger.debug("stderr: #{data}")
-              yield :stderr, data if block_given?
-            end
-
-            ch2.on_request("exit-status") do |ch3, data|
-              exit_status = data.read_long
-              @logger.debug("Exit status: #{exit_status}")
-            end
-
-            # Set the terminal
-            ch2.send_data "export TERM=vt100\n"
-
-            # Output the command
-            ch2.send_data "#{command}\n"
-
-            # Remember to exit or this channel will hang open
-            ch2.send_data "exit\n"
-
-            # Send eof to let server know we're done
-            ch2.eof!
-          end
-        end
-
-        # Wait for the channel to complete
-        channel.wait
-
-        # Return the final exit status
-        return exit_status
-      end
-
-      # Opens an SCP connection and yields it so that you can download
-      # and upload files.
-      def scp_connect
-        # Connect to SCP and yield the SCP object
-        connect do |connection|
-          scp = Net::SCP.new(connection)
-          return yield scp
-        end
-      rescue Net::SCP::Error => e
-        # If we get the exit code of 127, then this means SCP is unavailable.
-        raise Vagrant::Errors::SCPUnavailable if e.message =~ /\(127\)/
-
-        # Otherwise, just raise the error up
-        raise
-      end
-    end
-  end
-end