vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/push/command.rb

@@ -1,75 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandPush
-    class Command < Vagrant.plugin("2", :command)
-      def self.synopsis
-        "deploys code in this environment to a configured destination"
-      end
-
-      # @todo support multiple strategies if requested by the community
-      def execute
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant push [strategy] [options]"
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        name = validate_pushes!(@env.pushes, argv[0])
-
-        # Validate the configuration
-        @env.machine(@env.machine_names.first, @env.default_provider).action_raw(
-          :config_validate,
-          Vagrant::Action::Builtin::ConfigValidate)
-
-        @logger.debug("'push' environment with strategy: `#{name}'")
-        @env.push(name)
-
-        0
-      end
-
-      # Validate that the given list of names corresponds to valid pushes.
-      #
-      # @raise Vagrant::Errors::PushesNotDefined
-      #   if there are no pushes defined
-      # @raise Vagrant::Errors::PushStrategyNotProvided
-      #   if there are multiple push strategies defined and none were specified
-      # @raise Vagrant::Errors::PushStrategyNotDefined
-      #   if the given push name do not correspond to a push strategy
-      #
-      # @param [Array<Symbol>] pushes
-      #   the list of pushes defined by the environment
-      # @param [String] name
-      #   the name provided by the user on the command line
-      #
-      # @return [Symbol]
-      #   the compiled list of pushes
-      #
-      def validate_pushes!(pushes, name = nil)
-        if pushes.nil? || pushes.empty?
-          raise Vagrant::Errors::PushesNotDefined
-        end
-
-        if name.nil?
-          if pushes.length == 1
-            return pushes.first.to_sym
-          else
-            raise Vagrant::Errors::PushStrategyNotProvided,
-              pushes: pushes.map(&:to_s)
-          end
-        end
-
-        name = name.to_sym
-        if !pushes.include?(name)
-          raise Vagrant::Errors::PushStrategyNotDefined,
-            name: name.to_s,
-            pushes: pushes.map(&:to_s)
-        end
-
-        return name
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/push/plugin.rb

@@ -1,17 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandPush
-    class Plugin < Vagrant.plugin("2")
-      name "push command"
-      description <<-DESC
-      The `push` command deploys code in this environment.
-      DESC
-
-      command("push") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/rdp/command.rb

@@ -1,111 +0,0 @@
-require "optparse"
-
-module VagrantPlugins
-  module CommandRDP
-    class Command < Vagrant.plugin("2", :command)
-      def self.synopsis
-        "connects to machine via RDP"
-      end
-
-      def execute
-        options = {}
-
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant rdp [options] [name|id] [-- extra args]"
-        end
-
-        # Parse out the extra args to send to the RDP client, which
-        # is everything after the "--"
-        split_index = @argv.index("--")
-        if split_index
-          options[:extra_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
-
-        # Check if the host even supports RDP
-        raise Errors::HostUnsupported if !@env.host.capability?(:rdp_client)
-
-        # Execute RDP if we can
-        with_target_vms(argv, single_target: true) do |machine|
-          if !machine.communicate.ready?
-            raise Vagrant::Errors::VMNotCreatedError
-          end
-
-          machine.ui.output(I18n.t("vagrant_rdp.detecting"))
-          rdp_info = get_rdp_info(machine)
-          raise Errors::RDPUndetected if !rdp_info
-
-          # Extra arguments if we have any
-          rdp_info[:extra_args] = options[:extra_args]
-
-          machine.ui.detail(
-            "Address: #{rdp_info[:host]}:#{rdp_info[:port]}")
-          machine.ui.detail("Username: #{rdp_info[:username]}")
-
-          machine.ui.success(I18n.t("vagrant_rdp.connecting"))
-          @env.host.capability(:rdp_client, rdp_info)
-        end
-      end
-
-      protected
-
-      def get_rdp_info(machine)
-        rdp_info = {}
-        if machine.provider.capability?(:rdp_info)
-          rdp_info = machine.provider.capability(:rdp_info)
-          rdp_info ||= {}
-        end
-
-        ssh_info = machine.ssh_info
-
-        if !rdp_info[:username]
-          username = ssh_info[:username]
-          if machine.config.vm.communicator == :winrm
-            username = machine.config.winrm.username
-          end
-          rdp_info[:username] = username
-        end
-
-        if !rdp_info[:password]
-          password = ssh_info[:password]
-          if machine.config.vm.communicator == :winrm
-            password = machine.config.winrm.password
-          end
-          rdp_info[:password] = password
-        end
-
-        rdp_info[:host] ||= ssh_info[:host]
-        rdp_info[:port] ||= machine.config.rdp.port
-        rdp_info[:username] ||= machine.config.rdp.username
-
-        if rdp_info[:host] == "127.0.0.1"
-          # We need to find a forwarded port...
-          search_port = machine.config.rdp.search_port
-          ports       = nil
-          if machine.provider.capability?(:forwarded_ports)
-            ports = machine.provider.capability(:forwarded_ports)
-          else
-            ports = {}.tap do |result|
-              machine.config.vm.networks.each do |type, netopts|
-                next if type != :forwarded_port
-                next if !netopts[:host]
-                result[netopts[:host]] = netopts[:guest]
-              end
-            end
-          end
-
-          ports = ports.invert
-          port  = ports[search_port]
-          rdp_info[:port] = port
-          return nil if !port
-        end
-
-        return rdp_info
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/rdp/config.rb

@@ -1,26 +0,0 @@
-module VagrantPlugins
-  module CommandRDP
-    class Config < Vagrant.plugin("2", :config)
-      attr_accessor :port
-      attr_accessor :search_port
-      attr_accessor :username
-
-      def initialize
-        @port        = UNSET_VALUE
-        @search_port = UNSET_VALUE
-        @username = UNSET_VALUE
-      end
-
-      def finalize!
-        @port        = 3389 if @port == UNSET_VALUE
-        @search_port = 3389 if @search_port == UNSET_VALUE
-        @username = nil if @username == UNSET_VALUE
-      end
-
-      def validate(machine)
-        errors = _detected_errors
-        { "RDP" => errors }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/rdp/errors.rb

@@ -1,18 +0,0 @@
-module VagrantPlugins
-  module CommandRDP
-    module Errors
-      # A convenient superclass for all our errors.
-      class RDPError < Vagrant::Errors::VagrantError
-        error_namespace("vagrant_rdp.errors")
-      end
-
-      class HostUnsupported < RDPError
-        error_key(:host_unsupported)
-      end
-
-      class RDPUndetected < RDPError
-        error_key(:rdp_undetected)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/rdp/plugin.rb

@@ -1,36 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandRDP
-    autoload :Errors, File.expand_path("../errors", __FILE__)
-
-    class Plugin < Vagrant.plugin("2")
-      name "rdp command"
-      description <<-DESC
-      The rdp command opens a remote desktop Window to the
-      machine if it supports RDP.
-      DESC
-
-      command("rdp") do
-        require File.expand_path("../command", __FILE__)
-        init!
-        Command
-      end
-
-      config("rdp") do
-        require_relative "config"
-        Config
-      end
-
-      protected
-
-      def self.init!
-        return if defined?(@_init)
-        I18n.load_path << File.expand_path(
-          "templates/locales/command_rdp.yml", Vagrant.source_root)
-        I18n.reload!
-        @_init = true
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/reload/command.rb

@@ -1,61 +0,0 @@
-require 'optparse'
-
-require "vagrant"
-
-require Vagrant.source_root.join("plugins/commands/up/start_mixins")
-
-module VagrantPlugins
-  module CommandReload
-    class Command < Vagrant.plugin("2", :command)
-      # We assume that the `up` plugin exists and that we'll have access
-      # to this.
-      include VagrantPlugins::CommandUp::StartMixins
-
-      def self.synopsis
-        "restarts vagrant machine, loads new Vagrantfile configuration"
-      end
-
-      def execute
-        options = {}
-        options[:provision_ignore_sentinel] = false
-
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant reload [vm-name]"
-          o.separator ""
-          build_start_options(o, options)
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        # Validate the provisioners
-        validate_provisioner_flags!(options, argv)
-
-        @logger.debug("'reload' each target VM...")
-        machines = []
-        with_target_vms(argv) do |machine|
-          machines << machine
-          machine.action(:reload, options)
-        end
-
-        # Output the post-up messages that we have, if any
-        machines.each do |m|
-          next if !m.config.vm.post_up_message
-          next if m.config.vm.post_up_message == ""
-
-          # Add a newline to separate things.
-          @env.ui.info("", prefix: false)
-
-          m.ui.success(I18n.t(
-            "vagrant.post_up_message",
-            name: m.name.to_s,
-            message: m.config.vm.post_up_message))
-        end
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/reload/plugin.rb

@@ -1,18 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandReload
-    class Plugin < Vagrant.plugin("2")
-      name "reload command"
-      description <<-DESC
-      The `reload` command will halt, reconfigure your machine based on
-      the Vagrantfile, and bring it back up.
-      DESC
-
-      command("reload") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/resume/command.rb

@@ -1,43 +0,0 @@
-require 'optparse'
-
-require Vagrant.source_root.join("plugins/commands/up/start_mixins")
-
-module VagrantPlugins
-  module CommandResume
-    class Command < Vagrant.plugin("2", :command)
-      # We assume that the `up` plugin exists and that we'll have access
-      # to this.
-      include VagrantPlugins::CommandUp::StartMixins
-
-      def self.synopsis
-        "resume a suspended vagrant machine"
-      end
-
-      def execute
-        options = {}
-        options[:provision_ignore_sentinel] = false
-
-        opts = OptionParser.new do |o|
-          o.banner = "Usage: vagrant resume [vm-name]"
-          o.separator ""
-          build_start_options(o, options)
-        end
-
-        # Parse the options
-        argv = parse_options(opts)
-        return if !argv
-
-        # Validate the provisioners
-        validate_provisioner_flags!(options, argv)
-
-        @logger.debug("'resume' each target VM...")
-        with_target_vms(argv) do |machine|
-          machine.action(:resume, options)
-        end
-
-        # Success, exit status 0
-        0
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/resume/plugin.rb

@@ -1,17 +0,0 @@
-require "vagrant"
-
-module VagrantPlugins
-  module CommandResume
-    class Plugin < Vagrant.plugin("2")
-      name "resume command"
-      description <<-DESC
-      The `resume` command resumes a suspend virtual machine.
-      DESC
-
-      command("resume") do
-        require File.expand_path("../command", __FILE__)
-        Command
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/snapshot/command/delete.rb

@@ -1,47 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandSnapshot
-    module Command
-      class Delete < Vagrant.plugin("2", :command)
-        def execute
-          options = {}
-
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant snapshot delete [options] [vm-name] <name>"
-            o.separator ""
-            o.separator "Delete a snapshot taken previously with snapshot save."
-          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
-
-            snapshot_list = vm.provider.capability(:snapshot_list)
-
-            if snapshot_list.include? name
-              vm.action(:snapshot_delete, snapshot_name: name)
-            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/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/snapshot/command/list.rb

@@ -1,46 +0,0 @@
-require 'optparse'
-
-module VagrantPlugins
-  module CommandSnapshot
-    module Command
-      class List < Vagrant.plugin("2", :command)
-        def execute
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant snapshot list [options] [vm-name]"
-            o.separator ""
-            o.separator "List all snapshots taken for a machine."
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-
-          with_target_vms(argv) do |vm|
-            if !vm.id
-              vm.ui.info(I18n.t("vagrant.commands.common.vm_not_created"))
-              next
-            end
-
-            if !vm.provider.capability?(:snapshot_list)
-              raise Vagrant::Errors::SnapshotNotSupported
-            end
-
-            snapshots = vm.provider.capability(:snapshot_list)
-            if snapshots.empty?
-              vm.ui.output(I18n.t("vagrant.actions.vm.snapshot.list_none"))
-              vm.ui.detail(I18n.t("vagrant.actions.vm.snapshot.list_none_detail"))
-              next
-            end
-
-            snapshots.each do |snapshot|
-              vm.ui.output(snapshot, prefix: false)
-            end
-          end
-
-          # Success, exit status 0
-          0
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/snapshot/command/pop.rb

@@ -1,43 +0,0 @@
-require 'json'
-require 'optparse'
-
-require 'vagrant'
-
-require Vagrant.source_root.join("plugins/commands/up/start_mixins")
-
-require_relative "push_shared"
-
-module VagrantPlugins
-  module CommandSnapshot
-    module Command
-      class Pop < Vagrant.plugin("2", :command)
-        include PushShared
-        include VagrantPlugins::CommandUp::StartMixins
-
-        def execute
-          options = {}
-          options[:snapshot_delete] = true
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant snapshot pop [options] [vm-name]"
-            o.separator ""
-            build_start_options(o, options)
-            o.separator "Restore state that was pushed with `vagrant snapshot push`."
-
-            o.on("--no-delete", "Don't delete the snapshot after the restore") do
-                options[:snapshot_delete] = false
-            end
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-
-          # Validate the provisioners
-          validate_provisioner_flags!(options, argv)
-
-          return shared_exec(argv, method(:pop), options)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/snapshot/command/push.rb

@@ -1,33 +0,0 @@
-require 'json'
-require 'optparse'
-
-require_relative "push_shared"
-
-module VagrantPlugins
-  module CommandSnapshot
-    module Command
-      class Push < Vagrant.plugin("2", :command)
-        include PushShared
-
-        def execute
-          opts = OptionParser.new do |o|
-            o.banner = "Usage: vagrant snapshot push [options] [vm-name]"
-            o.separator ""
-            o.separator "Take a snapshot of the current state of the machine and 'push'"
-            o.separator "it onto the stack of states. You can use `vagrant snapshot pop`"
-            o.separator "to restore back to this state at any time."
-            o.separator ""
-            o.separator "If you use `vagrant snapshot save` or restore at any point after"
-            o.separator "a push, pop will still bring you back to this pushed state."
-          end
-
-          # Parse the options
-          argv = parse_options(opts)
-          return if !argv
-
-          return shared_exec(argv, method(:push))
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.5.0/bundler/gems/vagrant-04f7215b5e3f/plugins/commands/snapshot/command/push_shared.rb

@@ -1,55 +0,0 @@
-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