tnargav 1.2.2

data/plugins/commands/suspend/plugin.rb

@@ -0,0 +1,18 @@
+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/plugins/commands/up/command.rb

@@ -0,0 +1,57 @@
+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 = {}
+        options[:parallel] = true
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant up [vm-name] [options] [-h]"
+          o.separator ""
+
+          build_start_options(o, options)
+
+          o.on("--[no-]parallel",
+               "Enable or disable parallelism if provider supports it.") do |parallel|
+            options[:parallel] = parallel
+          end
+
+          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...")
+
+        # Build up the batch job of what we'll do
+        @env.batch(options[:parallel]) do |batch|
+          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))
+
+            batch.action(machine, :up, options)
+          end
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/up/plugin.rb

@@ -0,0 +1,17 @@
+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/plugins/commands/up/start_mixins.rb

@@ -0,0 +1,26 @@
+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/plugins/communicators/ssh/communicator.rb

@@ -0,0 +1,342 @@
+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 Exception => e
+            @logger.info("Connection errored, not re-using. Will reconnect.")
+            @logger.debug(e.inspect)
+            @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::EACCES,
+            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...")
+                @logger.info("  - Host: #{ssh_info[:host]}")
+                @logger.info("  - Port: #{ssh_info[:port]}")
+                @logger.info("  - Username: #{ssh_info[:username]}")
+                @logger.info("  - Key Path: #{ssh_info[:private_key_path]}")
+
+                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::EACCES
+          # This happens on connect() for unknown reasons yet...
+          raise Vagrant::Errors::SSHConnectEACCES
+        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
+
+        # 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
+
+        begin
+          keep_alive = nil
+
+          if @machine.config.ssh.keep_alive
+            # Begin sending keep-alive packets while we wait for the script
+            # to complete. This avoids connections closing on long-running
+            # scripts.
+            keep_alive = Thread.new do
+              loop do
+                sleep 5
+                @logger.debug("Sending SSH keep-alive...")
+                connection.send_global_request("keep-alive@openssh.com")
+              end
+            end
+          end
+
+          # Wait for the channel to complete
+          channel.wait
+        ensure
+          # Kill the keep-alive thread
+          keep_alive.kill if keep_alive
+        end
+
+        # 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

data/plugins/communicators/ssh/plugin.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommunicatorSSH
+    class Plugin < Vagrant.plugin("2")
+      name "ssh communicator"
+      description <<-DESC
+      This plugin allows Vagrant to communicate with remote machines using
+      SSH as the underlying protocol, powered internally by Ruby's
+      net-ssh library.
+      DESC
+
+      communicator("ssh") do
+        require File.expand_path("../communicator", __FILE__)
+        Communicator
+      end
+    end
+  end
+end

data/plugins/guests/arch/cap/change_host_name.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module GuestArch
+    module Cap
+      class ChangeHostName
+        def self.change_host_name(machine, name)
+          machine.communicate.tap do |comm|
+            # Only do this if the hostname is not already set
+            if !comm.test("sudo hostname | grep '#{name}'")
+              comm.sudo("sed -i 's/\\(HOSTNAME=\\).*/\\1#{name}/' /etc/rc.conf")
+              comm.sudo("hostname #{name}")
+              comm.sudo("sed -i 's@^\\(127[.]0[.]0[.]1[[:space:]]\\+\\)@\\1#{name} @' /etc/hosts")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/arch/cap/configure_networks.rb

@@ -0,0 +1,23 @@
+module VagrantPlugins
+  module GuestArch
+    module Cap
+      class ConfigureNetworks
+        def self.configure_networks(machine, networks)
+          networks.each do |network|
+            entry = TemplateRenderer.render("guests/arch/network_#{network[:type]}",
+                                            :options => network)
+
+            temp = Tempfile.new("vagrant")
+            temp.binmode
+            temp.write(entry)
+            temp.close
+
+            machine.communicate.upload(temp.path, "/tmp/vagrant_network")
+            machine.communicate.sudo("mv /tmp/vagrant_network /etc/network.d/interfaces/eth#{network[:interface]}")
+            machine.communicate.sudo("netcfg interfaces/eth#{network[:interface]}")
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/arch/guest.rb

@@ -0,0 +1,11 @@
+require "vagrant"
+
+module VagrantPlugins
+  module GuestArch
+    class Guest < Vagrant.plugin("2", :guest)
+      def detect?(machine)
+        machine.communicate.test("cat /etc/arch-release")
+      end
+    end
+  end
+end

data/plugins/guests/arch/plugin.rb

@@ -0,0 +1,25 @@
+require "vagrant"
+
+module VagrantPlugins
+  module GuestArch
+    class Plugin < Vagrant.plugin("2")
+      name "Arch guest"
+      description "Arch guest support."
+
+      guest("arch", "linux") do
+        require File.expand_path("../guest", __FILE__)
+        Guest
+      end
+
+      guest_capability("arch", "change_host_name") do
+        require_relative "cap/change_host_name"
+        Cap::ChangeHostName
+      end
+
+      guest_capability("arch", "configure_networks") do
+        require_relative "cap/configure_networks"
+        Cap::ConfigureNetworks
+      end
+    end
+  end
+end

data/plugins/guests/debian/cap/change_host_name.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module GuestDebian
+    module Cap
+      class ChangeHostName
+        def self.change_host_name(machine, name)
+          machine.communicate.tap do |comm|
+            if !comm.test("hostname --fqdn | grep '^#{name}$' || hostname --short | grep '^#{name}$'")
+              comm.sudo("sed -r -i 's/^(127[.]0[.]1[.]1[[:space:]]+).*$/\\1#{name} #{name.split('.')[0]}/' /etc/hosts")
+              comm.sudo("sed -i 's/.*$/#{name.split('.')[0]}/' /etc/hostname")
+              comm.sudo("hostname -F /etc/hostname")
+              comm.sudo("hostname --fqdn > /etc/mailname")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/debian/cap/configure_networks.rb

@@ -0,0 +1,61 @@
+require 'set'
+require 'tempfile'
+
+require "vagrant/util/template_renderer"
+
+module VagrantPlugins
+  module GuestDebian
+    module Cap
+      class ConfigureNetworks
+        include Vagrant::Util
+
+        def self.configure_networks(machine, networks)
+          machine.communicate.tap do |comm|
+            # First, remove any previous network modifications
+            # from the interface file.
+            comm.sudo("sed -e '/^#VAGRANT-BEGIN/,/^#VAGRANT-END/ d' /etc/network/interfaces > /tmp/vagrant-network-interfaces")
+            comm.sudo("su -c 'cat /tmp/vagrant-network-interfaces > /etc/network/interfaces'")
+            comm.sudo("rm /tmp/vagrant-network-interfaces")
+
+            # Accumulate the configurations to add to the interfaces file as
+            # well as what interfaces we're actually configuring since we use that
+            # later.
+            interfaces = Set.new
+            entries = []
+            networks.each do |network|
+              interfaces.add(network[:interface])
+              entry = TemplateRenderer.render("guests/debian/network_#{network[:type]}",
+                                              :options => network)
+
+              entries << entry
+            end
+
+            # Perform the careful dance necessary to reconfigure
+            # the network interfaces
+            temp = Tempfile.new("vagrant")
+            temp.binmode
+            temp.write(entries.join("\n"))
+            temp.close
+
+            comm.upload(temp.path, "/tmp/vagrant-network-entry")
+
+            # Bring down all the interfaces we're reconfiguring. By bringing down
+            # each specifically, we avoid reconfiguring eth0 (the NAT interface) so
+            # SSH never dies.
+            interfaces.each do |interface|
+              comm.sudo("/sbin/ifdown eth#{interface} 2> /dev/null")
+            end
+
+            comm.sudo("cat /tmp/vagrant-network-entry >> /etc/network/interfaces")
+            comm.sudo("rm /tmp/vagrant-network-entry")
+
+            # Bring back up each network interface, reconfigured
+            interfaces.each do |interface|
+              comm.sudo("/sbin/ifup eth#{interface}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/guests/debian/guest.rb

@@ -0,0 +1,9 @@
+module VagrantPlugins
+  module GuestDebian
+    class Guest < Vagrant.plugin("2", :guest)
+      def detect?(machine)
+        machine.communicate.test("cat /proc/version | grep 'Debian'")
+      end
+    end
+  end
+end

data/plugins/guests/debian/plugin.rb

@@ -0,0 +1,25 @@
+require "vagrant"
+
+module VagrantPlugins
+  module GuestDebian
+    class Plugin < Vagrant.plugin("2")
+      name "Debian guest"
+      description "Debian guest support."
+
+      guest("debian", "linux") do
+        require File.expand_path("../guest", __FILE__)
+        Guest
+      end
+
+      guest_capability("debian", "configure_networks") do
+        require_relative "cap/configure_networks"
+        Cap::ConfigureNetworks
+      end
+
+      guest_capability("debian", "change_host_name") do
+        require_relative "cap/change_host_name"
+        Cap::ChangeHostName
+      end
+    end
+  end
+end