vagrant 1.5.0 → 2.4.4

data/plugins/commands/snapshot/command/push_shared.rb

@@ -0,0 +1,58 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'json'
+
+module VagrantPlugins
+  module CommandSnapshot
+    module Command
+      module PushShared
+        def shared_exec(argv, m, opts={})
+          with_target_vms(argv) do |vm|
+            if !vm.id
+              vm.ui.info("Not created. Cannot push snapshot state.")
+              next
+            end
+
+            vm.env.lock("machine-snapshot-stack") do
+              m.call(vm, opts)
+            end
+          end
+
+          # Success, exit with 0
+          0
+        end
+
+        def push(machine, opts={})
+          snapshot_name = "push_#{Time.now.to_i}_#{rand(10000)}"
+
+          # Save the snapshot. This will raise an exception if it fails.
+          machine.action(:snapshot_save, snapshot_name: snapshot_name)
+        end
+
+        def pop(machine, opts={})
+          # By reverse sorting, we should be able to find the first
+          # pushed snapshot.
+          name = nil
+          snapshots = machine.provider.capability(:snapshot_list)
+          snapshots.sort.reverse.each do |snapshot|
+            if snapshot =~ /^push_\d+_\d+$/
+              name = snapshot
+              break
+            end
+          end
+
+          # If no snapshot was found, we never pushed
+          if !name
+            machine.ui.info(I18n.t("vagrant.commands.snapshot.no_push_snapshot"))
+            return
+          end
+
+          # Restore the snapshot and tell the provider to delete it, if required
+          opts[:snapshot_name] = name
+          machine.action(:snapshot_restore, opts)
+        end
+      end
+    end
+  end
+end

data/plugins/commands/snapshot/command/restore.rb

@@ -0,0 +1,67 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+require Vagrant.source_root.join("plugins/commands/up/start_mixins")
+
+module VagrantPlugins
+  module CommandSnapshot
+    module Command
+      class Restore < Vagrant.plugin("2", :command)
+
+        include VagrantPlugins::CommandUp::StartMixins
+
+        def execute
+          options = {}
+          options[:provision_ignore_sentinel] = false
+          options[:snapshot_start] = true
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant snapshot restore [options] [vm-name] <name>"
+            o.separator ""
+            build_start_options(o, options)
+            o.separator "Restore a snapshot taken previously with snapshot save."
+
+            o.on("--no-start", "Don't start the snapshot after the restore") do
+              options[:snapshot_start] = false
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          if argv.empty? || argv.length > 2
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          # Validate the provisioners
+          validate_provisioner_flags!(options, argv)
+
+          name = argv.pop
+          options[:snapshot_name] = name
+
+          with_target_vms(argv) do |vm|
+            if !vm.provider.capability?(:snapshot_list)
+              raise Vagrant::Errors::SnapshotNotSupported
+            end
+
+            snapshot_list = vm.provider.capability(:snapshot_list)
+
+            if snapshot_list.include? name
+              vm.action(:snapshot_restore, options)
+            else
+              raise Vagrant::Errors::SnapshotNotFound,
+                snapshot_name: name,
+                machine: vm.name.to_s
+            end
+          end
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/snapshot/command/root.rb

@@ -0,0 +1,95 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandSnapshot
+    module Command
+      class Root < Vagrant.plugin("2", :command)
+        def self.synopsis
+          "manages snapshots: saving, restoring, etc."
+        end
+
+        def initialize(argv, env)
+          super
+
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:save) do
+            require_relative "save"
+            Save
+          end
+
+          @subcommands.register(:restore) do
+            require_relative "restore"
+            Restore
+          end
+
+          @subcommands.register(:delete) do
+            require_relative "delete"
+            Delete
+          end
+
+          @subcommands.register(:list) do
+            require_relative "list"
+            List
+          end
+
+          @subcommands.register(:push) do
+            require_relative "push"
+            Push
+          end
+
+          @subcommands.register(:pop) do
+            require_relative "pop"
+            Pop
+          end
+        end
+
+        def execute
+          if @main_args.include?("-h") || @main_args.include?("--help")
+            # Print the help for all the commands.
+            @env.ui.info(help, prefix: false)
+            return 0
+          end
+
+          # If we reached this far then we must have a subcommand. If not,
+          # then we also just print the help and exit.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          if !command_class || !@sub_command
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: help()
+          end
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        # Prints the help out for this command
+        def help
+          opts = OptionParser.new do |opts|
+            opts.banner = "Usage: vagrant snapshot <subcommand> [<args>]"
+            opts.separator ""
+            opts.separator "Available subcommands:"
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              opts.separator "     #{key}"
+            end
+            opts.separator ""
+            opts.separator "For help on any individual subcommand run `vagrant snapshot <subcommand> -h`"
+          end
+
+          opts.help
+        end
+      end
+    end
+  end
+end

data/plugins/commands/snapshot/command/save.rb

@@ -0,0 +1,75 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandSnapshot
+    module Command
+      class Save < Vagrant.plugin("2", :command)
+        def execute
+          options = {}
+          options[:force] = false
+
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant snapshot save [options] [vm-name] <name>"
+            o.separator ""
+            o.separator "Take a snapshot of the current state of the machine. The snapshot"
+            o.separator "can be restored via `vagrant snapshot restore` at any point in the"
+            o.separator "future to get back to this exact machine state."
+            o.separator ""
+            o.separator "If no vm-name is given, Vagrant will take a snapshot of"
+            o.separator "the entire environment with the same snapshot name."
+            o.separator ""
+            o.separator "Snapshots are useful for experimenting in a machine and being able"
+            o.separator "to rollback quickly."
+
+            o.on("-f", "--force", "Replace snapshot without confirmation") do |f|
+              options[:force] = f
+            end
+          end
+
+          # Parse the options
+          argv = parse_options(opts)
+          return if !argv
+          if argv.empty? || argv.length > 2
+            raise Vagrant::Errors::CLIInvalidUsage,
+              help: opts.help.chomp
+          end
+
+          name = argv.pop
+
+          with_target_vms(argv) do |vm|
+            if !vm.provider.capability?(:snapshot_list)
+              raise Vagrant::Errors::SnapshotNotSupported
+            end
+
+            # In this case, no vm name was given, and we are iterating over the
+            # entire environment. If a vm hasn't been created yet, we can't list
+            # its snapshots
+            if vm.id.nil?
+              @env.ui.warn(I18n.t("vagrant.commands.snapshot.save.vm_not_created",
+                                  name: vm.name))
+              next
+            end
+
+            snapshot_list = vm.provider.capability(:snapshot_list)
+
+            if !snapshot_list.include? name
+              vm.action(:snapshot_save, snapshot_name: name)
+            elsif options[:force]
+              # not a unique snapshot name
+              vm.action(:snapshot_delete, snapshot_name: name)
+              vm.action(:snapshot_save, snapshot_name: name)
+            else
+              raise Vagrant::Errors::SnapshotConflictFailed
+            end
+          end
+
+          # Success, exit status 0
+          0
+        end
+      end
+    end
+  end
+end

data/plugins/commands/snapshot/plugin.rb

@@ -0,0 +1,18 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require "vagrant"
+
+module VagrantPlugins
+  module CommandSnapshot
+    class Plugin < Vagrant.plugin("2")
+      name "snapshot command"
+      description "The `snapshot` command gives you a way to manage snapshots."
+
+      command("snapshot") do
+        require_relative "command/root"
+        Command::Root
+      end
+    end
+  end
+end

data/plugins/commands/ssh/command.rb

@@ -0,0 +1,80 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandSSH
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "connects to machine via SSH"
+      end
+
+      def execute
+        options = {}
+        options[:tty] = true
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant ssh [options] [name|id] [-- extra ssh args]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("-c", "--command COMMAND", "Execute an SSH command directly") do |c|
+            options[:command] = c
+          end
+
+          o.on("-p", "--plain", "Plain mode, leaves authentication up to user") do |p|
+            options[:plain_mode] = p
+          end
+
+          o.on("-t", "--[no-]tty", "Enables tty when executing an ssh command (defaults to true)") do |t|
+            options[:tty] = t
+          end
+        end
+
+        # Parse out the extra args to send to SSH, which is everything
+        # after the "--"
+        split_index = @argv.index("--")
+        if split_index
+          options[:ssh_args] = @argv.drop(split_index + 1)
+          @argv              = @argv.take(split_index)
+        end
+
+        # Parse the options and return if we don't have any target.
+        argv = parse_options(opts)
+        return if !argv
+
+        # Execute the actual SSH
+        with_target_vms(argv, single_target: true) do |vm|
+          ssh_opts = {
+            plain_mode: options[:plain_mode],
+            extra_args: options[:ssh_args]
+          }
+
+          if options[:command]
+            @logger.debug("Executing single command on remote machine: #{options[:command]}")
+            env = vm.action(:ssh_run,
+                            ssh_opts: ssh_opts,
+                            ssh_run_command: options[:command],
+                            tty: options[:tty],)
+
+            # Exit with the exit status of the command or a 0 if we didn't
+            # get one.
+            exit_status = env[:ssh_run_exit_status] || 0
+            return exit_status
+          else
+            Vagrant::Bundler.instance.deinit
+            @logger.debug("Invoking `ssh` action on machine")
+            vm.action(:ssh, ssh_opts: ssh_opts)
+
+            # We should never reach this point, since the point of `ssh`
+            # is to exec into the proper SSH shell, but we'll just return
+            # an exit status of 0 anyways.
+            return 0
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/commands/ssh/plugin.rb

@@ -0,0 +1,20 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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/plugins/commands/ssh_config/command.rb

@@ -0,0 +1,78 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+require "vagrant/util/safe_puts"
+require "vagrant/util/platform"
+
+module VagrantPlugins
+  module CommandSSHConfig
+    class Command < Vagrant.plugin("2", :command)
+      include Vagrant::Util::SafePuts
+
+      def self.synopsis
+        "outputs OpenSSH valid configuration to connect to the machine"
+      end
+
+      def convert_win_paths(paths)
+        paths.map! { |path| Vagrant::Util::Platform.format_windows_path(path, :disable_unc) }
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant ssh-config [options] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.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) do |machine|
+          ssh_info = machine.ssh_info
+          raise Vagrant::Errors::SSHNotReady if ssh_info.nil?
+
+          if Vagrant::Util::Platform.windows?
+            ssh_info[:private_key_path] = convert_win_paths(ssh_info[:private_key_path])
+          end
+
+          variables = {
+            host_key: options[:host] || machine.name || "vagrant",
+            ssh_host: ssh_info[:host],
+            ssh_port: ssh_info[:port],
+            ssh_user: ssh_info[:username],
+            keys_only: ssh_info[:keys_only],
+            verify_host_key: ssh_info[:verify_host_key],
+            private_key_path: ssh_info[:private_key_path],
+            log_level: ssh_info[:log_level],
+            forward_agent: ssh_info[:forward_agent],
+            forward_x11:   ssh_info[:forward_x11],
+            proxy_command: ssh_info[:proxy_command],
+            ssh_command:   ssh_info[:ssh_command],
+            forward_env:   ssh_info[:forward_env],
+            config:        ssh_info[:config],
+            disable_deprecated_algorithms: ssh_info[:disable_deprecated_algorithms]
+          }
+
+          # Render the template and output directly to STDOUT
+          template = "commands/ssh_config/config"
+          config   = Vagrant::Util::TemplateRenderer.render(template, variables)
+          machine.ui.machine("ssh-config", config)
+          safe_puts(config)
+          safe_puts
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/ssh_config/plugin.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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/plugins/commands/status/command.rb

@@ -0,0 +1,59 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandStatus
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "outputs status of the vagrant machine"
+      end
+
+      def execute
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant status [name|id]"
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        max_name_length = 25
+        with_target_vms(argv) do |machine|
+          max_name_length = machine.name.length if machine.name.length > max_name_length
+        end
+
+        state = nil
+        results = []
+        with_target_vms(argv) do |machine|
+          state = machine.state if !state
+          current_state = machine.state
+          results << "#{machine.name.to_s.ljust(max_name_length)} " +
+            "#{current_state.short_description} (#{machine.provider_name})"
+
+          opts = { target: machine.name.to_s }
+          @env.ui.machine("provider-name", machine.provider_name, opts)
+          @env.ui.machine("state", current_state.id, opts)
+          @env.ui.machine("state-human-short", current_state.short_description, opts)
+          @env.ui.machine("state-human-long", current_state.long_description, opts)
+        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/plugins/commands/status/plugin.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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/plugins/commands/suspend/command.rb

@@ -0,0 +1,49 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+require 'optparse'
+
+module VagrantPlugins
+  module CommandSuspend
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "suspends the machine"
+      end
+
+      def execute
+        options = {}
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant suspend [options] [name|id]"
+          o.separator ""
+          o.on("-a", "--all-global", "Suspend all running vms globally.") do |p|
+            options[:all] = true
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("'suspend' each target VM...")
+        target = []
+        if options[:all]
+          if argv.size > 0
+            raise Vagrant::Errors::CommandSuspendAllArgs
+          end
+
+          m = @env.machine_index.each { |m| m }
+          target = m.keys
+        else
+          target = argv
+        end
+
+        with_target_vms(target) do |vm|
+          vm.action(:suspend)
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/plugins/commands/suspend/plugin.rb

@@ -0,0 +1,21 @@
+# Copyright (c) HashiCorp, Inc.
+# SPDX-License-Identifier: BUSL-1.1
+
+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