vagrant 1.0.7 → 1.5.0

data/lib/vagrant/command/provision.rb

@@ -1,40 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Provision < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant provision [vm-name]"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        # Go over each VM and provision!
-        @logger.debug("'provision' each target VM...")
-        with_target_vms(argv) do |vm|
-          
-          if vm.created?
-            if vm.state == :running
-              @logger.info("Provisioning: #{vm.name}")
-              vm.provision
-            else
-              @logger.info("#{vm.name} not running. Not provisioning.")
-              vm.ui.info I18n.t("vagrant.commands.common.vm_not_running")
-            end
-          else
-            @logger.info("#{vm.name} not created. Not provisioning.")
-            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/reload.rb

@@ -1,39 +0,0 @@
-require 'optparse'
-
-require 'vagrant/command/start_mixins'
-
-module Vagrant
-  module Command
-    class Reload < Base
-      include StartMixins
-
-      def execute
-        options = {}
-
-          opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant reload [vm-name]"
-          opts.separator ""
-          build_start_options(opts, options)
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        @logger.debug("'reload' each target VM...")
-        with_target_vms(argv) do |vm|
-          if vm.created?
-            @logger.info("Reloading: #{vm.name}")
-            vm.reload(options)
-          else
-            @logger.info("Not created: #{vm.name}. Not reloading.")
-            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/resume.rb

@@ -1,33 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Resume < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant resume [vm-name]"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        @logger.debug("'resume' each target VM...")
-        with_target_vms(argv) do |vm|
-          if vm.created?
-            @logger.info("Resume: #{vm.name}")
-            vm.resume
-          else
-            @logger.info("Not created: #{vm.name}. Not resuming.")
-            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/ssh.rb

@@ -1,90 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class SSH < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant ssh [vm-name] [-c command] [-- extra ssh args]"
-
-          opts.separator ""
-
-          opts.on("-c", "--command COMMAND", "Execute an SSH command directly.") do |c|
-            options[:command] = c
-          end
-          opts.on("-p", "--plain", "Plain mode, leaves authentication up to user.") do |p|
-            options[:plain_mode] = p
-          end
-        end
-
-        # Parse the options and return if we don't have any target.
-        argv = parse_options(opts)
-        return if !argv
-
-        # Parse out the extra args to send to SSH, which is everything
-        # after the "--"
-        ssh_args = ARGV.drop_while { |i| i != "--" }
-        ssh_args = ssh_args[1..-1]
-        options[:ssh_args] = ssh_args
-
-        # If the remaining arguments ARE the SSH arguments, then just
-        # clear it out. This happens because optparse returns what is
-        # after the "--" as remaining ARGV, and Vagrant can think it is
-        # a multi-vm name (wrong!)
-        argv = [] if argv == ssh_args
-
-        # Execute the actual SSH
-        with_target_vms(argv, :single_target => true) do |vm|
-          # Basic checks that are required for proper SSH
-          raise Errors::VMNotCreatedError if !vm.created?
-          raise Errors::VMInaccessible if !vm.state == :inaccessible
-          raise Errors::VMNotRunningError if vm.state != :running
-
-          if options[:command]
-            ssh_execute(vm, options[:command])
-          else
-            opts = {
-              :plain_mode => options[:plain_mode],
-              :extra_args => options[:ssh_args]
-            }
-
-            ssh_connect(vm, opts)
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-
-      protected
-
-      def ssh_execute(vm, command=nil)
-        exit_status = 0
-
-        @logger.debug("Executing command: #{command}")
-        exit_status = vm.channel.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 SSH output as it comes in, but don't prefix it and don't
-          # force a new line so that the output is properly preserved
-          vm.ui.info(data.to_s,
-                     :prefix => false,
-                     :new_line => false,
-                     :channel => channel)
-        end
-
-        # Exit with the exit status we got from executing the command
-        exit exit_status
-      end
-
-      def ssh_connect(vm, opts)
-        @logger.debug("`exec` into ssh prompt")
-        vm.ssh.exec(opts)
-      end
-    end
-  end
-end

data/lib/vagrant/command/ssh_config.rb

@@ -1,51 +0,0 @@
-require 'optparse'
-
-require "vagrant/util/safe_puts"
-
-module Vagrant
-  module Command
-    class SSHConfig < Base
-      include Util::SafePuts
-
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant ssh-config [vm-name] [--host name]"
-
-          opts.separator ""
-
-          opts.on("--host NAME", "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 |vm|
-          raise Errors::VMNotCreatedError if !vm.created?
-          raise Errors::VMInaccessible if !vm.state == :inaccessible
-
-          ssh_info  = vm.ssh.info
-          variables = {
-            :host_key => options[:host] || vm.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(Util::TemplateRenderer.render(template, variables))
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/start_mixins.rb

@@ -1,26 +0,0 @@
-module Vagrant
-  module Command
-    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
-        end
-      end
-    end
-  end
-end

data/lib/vagrant/command/status.rb

@@ -1,36 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Status < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant status [vm-name]"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        state = nil
-        results = []
-        with_target_vms(argv) do |vm|
-          state = vm.state.to_s if !state
-          results << "#{vm.name.to_s.ljust(25)}#{vm.state.to_s.gsub("_", " ")}"
-        end
-
-        state = results.length == 1 ? state : "listing"
-
-        @env.ui.info(I18n.t("vagrant.commands.status.output",
-                            :states => results.join("\n"),
-                            :message => I18n.t("vagrant.commands.status.#{state}")),
-                     :prefix => false)
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/suspend.rb

@@ -1,33 +0,0 @@
-require 'optparse'
-
-module Vagrant
-  module Command
-    class Suspend < Base
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |opts|
-          opts.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|
-          if vm.created?
-            @logger.info("Suspending: #{vm.name}")
-            vm.suspend
-          else
-            @logger.info("Not created: #{vm.name}. Not suspending.")
-            vm.ui.info I18n.t("vagrant.commands.common.vm_not_created")
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/command/up.rb

@@ -1,40 +0,0 @@
-require 'optparse'
-
-require 'vagrant/command/start_mixins'
-
-module Vagrant
-  module Command
-    class Up < Base
-      include StartMixins
-
-      def execute
-        options = {}
-        opts = OptionParser.new do |opts|
-          opts.banner = "Usage: vagrant up [vm-name] [--[no-]provision] [-h]"
-          opts.separator ""
-          build_start_options(opts, options)
-        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) do |vm|
-          if vm.created?
-            @logger.info("Booting: #{vm.name}")
-            vm.ui.info I18n.t("vagrant.commands.up.vm_created")
-            vm.start(options)
-          else
-            @logger.info("Creating: #{vm.name}")
-            vm.up(options)
-          end
-        end
-
-        # Success, exit status 0
-        0
-       end
-    end
-  end
-end

data/lib/vagrant/communication.rb

@@ -1,7 +0,0 @@
-module Vagrant
-  module Communication
-    autoload :Base, 'vagrant/communication/base'
-
-    autoload :SSH,  'vagrant/communication/ssh'
-  end
-end

data/lib/vagrant/communication/base.rb

@@ -1,56 +0,0 @@
-module Vagrant
-  module Communication
-    # The base class for any classes that provide an API for communicating
-    # with the virtual machine.
-    #
-    # There are various stages that require Vagrant to copy files or
-    # run commands on the target system, and communication classes provide
-    # the abstraction necessary to perform these tasks, via SSH or some
-    # other mechanism.
-    #
-    # Any subclasses of this class **must** implement all of the methods
-    # below.
-    class Base
-      # Checks if the target machine is ready for communication.
-      #
-      # @return [Boolean]
-      def ready?
-      end
-
-      # Upload a file to the virtual machine.
-      #
-      # @param [String] from Path to a file to upload.
-      # @param [String] to Path to where to save this file.
-      def upload(from, to)
-      end
-
-      # Execute a command on the remote machine.
-      #
-      # @param [String] command Command to execute.
-      # @yield [type, data] Realtime output of the command being executed.
-      # @yieldparam [String] type Type of the output, `:stdout`, `:stderr`, etc.
-      # @yieldparam [String] data Data for the given output.
-      # @return [Integer] Exit code of the command.
-      def execute(command, opts=nil)
-      end
-
-      # Execute a comand with super user privileges.
-      #
-      # See #execute for parameter information.
-      def sudo(command, opts=nil)
-      end
-
-      # Executes a command and returns a boolean statement if it was successful
-      # or not.
-      #
-      # This is implemented by default as expecting `execute` to return 0.
-      def test(command, opts=nil)
-        # Disable error checking no matter what
-        opts = (opts || {}).merge(:error_check => false)
-
-        # Successful if the exit status is 0
-        execute(command, opts) == 0
-      end
-    end
-  end
-end