vagrant-aws-detiber 0.7.2.pre.2

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/destroy/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandDestroy
+    class Plugin < Vagrant.plugin("2")
+      name "destroy command"
+      description <<-DESC
+      The `destroy` command deletes and removes the files and record of your virtual machines.
+      All data is lost and a new VM will have to be created using `up`
+      DESC
+
+      command("destroy") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/global-status/command.rb

@@ -0,0 +1,100 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandGlobalStatus
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "outputs status Vagrant environments for this user"
+      end
+
+      def execute
+        options = {}
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant global-status"
+          o.separator ""
+          o.on("--prune", "Prune invalid entries.") do |p|
+            options[:prune] = true
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        columns = [
+          ["id", :id],
+          ["name", :name],
+          ["provider", :provider],
+          ["state", :state],
+          ["directory", :vagrantfile_path],
+        ]
+
+        widths = {}
+        widths[:id] = 8
+        widths[:name] = 6
+        widths[:provider] = 6
+        widths[:state] = 6
+        widths[:vagrantfile_path] = 35
+
+        entries = []
+        prune   = []
+        @env.machine_index.each do |entry|
+          # If we're pruning and this entry is invalid, skip it
+          # and prune it later.
+          if options[:prune] && !entry.valid?(@env.home_path)
+            prune << entry
+            next
+          end
+
+          entries << entry
+
+          columns.each do |_, method|
+            # Skip the id
+            next if method == :id
+
+            widths[method] ||= 0
+            cur = entry.send(method).to_s.length
+            widths[method] = cur if cur > widths[method]
+          end
+        end
+
+        # Prune all the entries to prune
+        prune.each do |entry|
+          deletable = @env.machine_index.get(entry.id)
+          @env.machine_index.delete(deletable) if deletable
+        end
+
+        total_width = 0
+        columns.each do |header, method|
+          header = header.ljust(widths[method]) if widths[method]
+          @env.ui.info("#{header} ", new_line: false)
+          total_width += header.length + 1
+        end
+        @env.ui.info("")
+        @env.ui.info("-" * total_width)
+
+        if entries.empty?
+          @env.ui.info(I18n.t("vagrant.global_status_none"))
+          return 0
+        end
+
+        entries.each do |entry|
+          columns.each do |_, method|
+            v = entry.send(method).to_s
+            v = v[0...7] if method == :id
+            v = v.ljust(widths[method]) if widths[method]
+            @env.ui.info("#{v} ", new_line: false)
+          end
+
+          @env.ui.info("")
+        end
+
+        @env.ui.info(" \n" + I18n.t("vagrant.global_status_footer"))
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/global-status/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandGlobalStatus
+    class Plugin < Vagrant.plugin("2")
+      name "global-status command"
+      description <<-DESC
+      The `global-status` command shows what the running state (running/saved/..)
+      is of all the Vagrant environments known to the system.
+      DESC
+
+      command("global-status") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/halt/command.rb

@@ -0,0 +1,39 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandHalt
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "stops the vagrant machine"
+      end
+
+      def execute
+        options = {}
+        options[:force] = false
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant halt [options] [name|id]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("-f", "--force", "Force shut down (equivalent of pulling power)") do |f|
+            options[:force] = f
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        @logger.debug("Halt command: #{argv.inspect} #{options.inspect}")
+        with_target_vms(argv, reverse: true) do |vm|
+          vm.action(:halt, force_halt: options[:force])
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/halt/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandHalt
+    class Plugin < Vagrant.plugin("2")
+      name "halt command"
+      description <<-DESC
+      The `halt` command shuts your virtual machine down forcefully.
+      The command `up` recreates it.
+      DESC
+
+      command("halt") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/help/command.rb

@@ -0,0 +1,16 @@
+require 'optparse'
+
+module VagrantPlugins
+  module CommandHelp
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "shows the help for a subcommand"
+      end
+
+      def execute
+        return @env.cli([]) if @argv.empty?
+        @env.cli([@argv[0], "-h"])
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/help/plugin.rb

@@ -0,0 +1,17 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandHelp
+    class Plugin < Vagrant.plugin("2")
+      name "help command"
+      description <<-DESC
+      The `help` command shows help for the given command.
+      DESC
+
+      command("help") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/init/command.rb

@@ -0,0 +1,107 @@
+require 'optparse'
+
+require 'vagrant/util/template_renderer'
+
+module VagrantPlugins
+  module CommandInit
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "initializes a new Vagrant environment by creating a Vagrantfile"
+      end
+
+      def execute
+        options = {
+          force: false,
+          minimal: false,
+          output: "Vagrantfile",
+          template: nil
+        }
+
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant init [options] [name [url]]"
+          o.separator ""
+          o.separator "Options:"
+          o.separator ""
+
+          o.on("--box-version VERSION", "Version of the box to add") do |f|
+            options[:box_version] = f
+          end
+
+          o.on("-f", "--force", "Overwrite existing Vagrantfile") do |f|
+            options[:force] = f
+          end
+
+          o.on("-m", "--minimal", "Use minimal Vagrantfile template (no help comments). Ignored with --template") do |m|
+            options[:minimal] = m
+          end
+
+          o.on("--output FILE", String,
+               "Output path for the box. '-' for stdout") do |output|
+            options[:output] = output
+          end
+
+          o.on("--template FILE", String, "Path to custom Vagrantfile template") do |template|
+            options[:template] = template
+          end
+        end
+
+        # Parse the options
+        argv = parse_options(opts)
+        return if !argv
+
+        save_path = nil
+        if options[:output] != "-"
+          save_path = Pathname.new(options[:output]).expand_path(@env.cwd)
+          save_path.delete if save_path.exist? && options[:force]
+          raise Vagrant::Errors::VagrantfileExistsError if save_path.exist?
+        end
+
+        # Determine the template and template root to use
+        template_root = ""
+        if options[:template].nil?
+          options[:template] = "Vagrantfile"
+
+          if options[:minimal]
+            options[:template] = "Vagrantfile.min"
+          end
+
+          template_root = ::Vagrant.source_root.join("templates/commands/init")
+        end
+
+        # Strip the .erb extension off the template if the user passes it in
+        options[:template] = options[:template].chomp(".erb")
+
+        # Make sure the template actually exists
+        full_template_path = Vagrant::Util::TemplateRenderer.new(options[:template], template_root: template_root).full_template_path
+        if !File.file?(full_template_path)
+          raise Vagrant::Errors::VagrantfileTemplateNotFoundError, path: full_template_path
+        end
+
+        contents = Vagrant::Util::TemplateRenderer.render(options[:template],
+          box_name: argv[0] || "base",
+          box_url: argv[1],
+          box_version: options[:box_version],
+          template_root: template_root
+        )
+
+        if save_path
+          # Write out the contents
+          begin
+            save_path.open("w+") do |f|
+              f.write(contents)
+            end
+          rescue Errno::EACCES
+            raise Vagrant::Errors::VagrantfileWriteError
+          end
+
+          @env.ui.info(I18n.t("vagrant.commands.init.success"), prefix: false)
+        else
+          @env.ui.info(contents, prefix: false)
+        end
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/init/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandInit
+    class Plugin < Vagrant.plugin("2")
+      name "init command"
+      description <<-DESC
+      The `init` command sets up your working directory to be a
+      Vagrant-managed environment.
+      DESC
+
+      command("init") do
+        require File.expand_path("../command", __FILE__)
+        Command
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/list-commands/command.rb

@@ -0,0 +1,43 @@
+require "optparse"
+
+module VagrantPlugins
+  module CommandListCommands
+    class Command < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "outputs all available Vagrant subcommands, even non-primary ones"
+      end
+
+      def execute
+        opts = OptionParser.new do |o|
+          o.banner = "Usage: vagrant list-commands"
+        end
+
+        argv = parse_options(opts)
+        return if !argv
+
+        # Add the available subcommands as separators in order to print them
+        # out as well.
+        commands = {}
+        longest = 0
+        Vagrant.plugin("2").manager.commands.each do |key, data|
+          key           = key.to_s
+          klass         = data[0].call
+          commands[key] = klass.synopsis
+          longest       = key.length if key.length > longest
+        end
+
+        command_output = []
+        commands.keys.sort.each do |key|
+          command_output << "#{key.ljust(longest+2)} #{commands[key]}"
+          @env.ui.machine("cli-command", key.dup)
+        end
+
+        @env.ui.info(
+          I18n.t("vagrant.list_commands", list: command_output.join("\n")))
+
+        # Success, exit status 0
+        0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/list-commands/plugin.rb

@@ -0,0 +1,18 @@
+require "vagrant"
+
+module VagrantPlugins
+  module CommandListCommands
+    class Plugin < Vagrant.plugin("2")
+      name "list-commands command"
+      description <<-DESC
+      The `list-commands` command will list all commands that Vagrant
+      understands, even hidden ones.
+      DESC
+
+      command("list-commands", primary: false) do
+        require_relative "command"
+        Command
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-419afb4dcffe/plugins/commands/login/client.rb

@@ -0,0 +1,253 @@
+require "rest_client"
+require "vagrant/util/downloader"
+require "vagrant/util/presence"
+
+module VagrantPlugins
+  module LoginCommand
+    class Client
+      APP = "app".freeze
+
+      include Vagrant::Util::Presence
+
+      attr_accessor :username_or_email
+      attr_accessor :password
+      attr_reader :two_factor_default_delivery_method
+      attr_reader :two_factor_delivery_methods
+
+      # Initializes a login client with the given Vagrant::Environment.
+      #
+      # @param [Vagrant::Environment] env
+      def initialize(env)
+        @logger = Log4r::Logger.new("vagrant::login::client")
+        @env    = env
+      end
+
+      # Removes the token, effectively logging the user out.
+      def clear_token
+        @logger.info("Clearing token")
+        token_path.delete if token_path.file?
+      end
+
+      # Checks if the user is logged in by verifying their authentication
+      # token.
+      #
+      # @return [Boolean]
+      def logged_in?
+        token = self.token
+        return false if !token
+
+        with_error_handling do
+          url = "#{Vagrant.server_url}/api/v1/authenticate" +
+            "?access_token=#{token}"
+          RestClient.get(url, content_type: :json)
+          true
+        end
+      rescue Errors::Unauthorized
+        false
+      end
+
+      # Login logs a user in and returns the token for that user. The token
+      # is _not_ stored unless {#store_token} is called.
+      #
+      # @param [String] description
+      # @param [String] code
+      # @return [String] token The access token, or nil if auth failed.
+      def login(description: nil, code: nil)
+        @logger.info("Logging in '#{username_or_email}'")
+
+        response = post(
+          "/api/v1/authenticate", {
+            user: {
+              login: username_or_email,
+              password: password
+            },
+            token: {
+              description: description
+            },
+            two_factor: {
+              code: code
+            }
+          }
+        )
+
+        response["token"]
+      end
+
+      # Requests a 2FA code
+      # @param [String] delivery_method
+      def request_code(delivery_method)
+        @env.ui.warn("Requesting 2FA code via #{delivery_method.upcase}...")
+
+        response = post(
+          "/api/v1/two-factor/request-code", {
+            user: {
+              login: username_or_email,
+              password: password
+            },
+            two_factor: {
+              delivery_method: delivery_method.downcase
+            }
+          }
+        )
+
+        two_factor = response['two_factor']
+        obfuscated_destination = two_factor['obfuscated_destination']
+
+        @env.ui.success("2FA code sent to #{obfuscated_destination}.")
+      end
+
+      # Issues a post to a Vagrant Cloud path with the given payload.
+      # @param [String] path
+      # @param [Hash] payload
+      # @return [Hash] response data
+      def post(path, payload)
+        with_error_handling do
+          url = File.join(Vagrant.server_url, path)
+
+          proxy   = nil
+          proxy ||= ENV["HTTPS_PROXY"] || ENV["https_proxy"]
+          proxy ||= ENV["HTTP_PROXY"]  || ENV["http_proxy"]
+          RestClient.proxy = proxy
+
+          response = RestClient::Request.execute(
+            method: :post,
+            url: url,
+            payload: JSON.dump(payload),
+            proxy: proxy,
+            headers: {
+              accept: :json,
+              content_type: :json,
+              user_agent: Vagrant::Util::Downloader::USER_AGENT,
+            },
+          )
+
+          JSON.load(response.to_s)
+        end
+      end
+
+      # Stores the given token locally, removing any previous tokens.
+      #
+      # @param [String] token
+      def store_token(token)
+        @logger.info("Storing token in #{token_path}")
+
+        token_path.open("w") do |f|
+          f.write(token)
+        end
+
+        nil
+      end
+
+      # Reads the access token if there is one. This will first read the
+      # `VAGRANT_CLOUD_TOKEN` environment variable and then fallback to the stored
+      # access token on disk.
+      #
+      # @return [String]
+      def token
+        if present?(ENV["VAGRANT_CLOUD_TOKEN"]) && token_path.exist?
+          @env.ui.warn <<-EOH.strip
+Vagrant detected both the VAGRANT_CLOUD_TOKEN environment variable and a Vagrant login
+token are present on this system. The VAGRANT_CLOUD_TOKEN environment variable takes
+precedence over the locally stored token. To remove this error, either unset
+the VAGRANT_CLOUD_TOKEN environment variable or remove the login token stored on disk:
+
+    ~/.vagrant.d/data/vagrant_login_token
+
+EOH
+        end
+
+        if present?(ENV["VAGRANT_CLOUD_TOKEN"])
+          @logger.debug("Using authentication token from environment variable")
+          return ENV["VAGRANT_CLOUD_TOKEN"]
+        end
+
+        if token_path.exist?
+          @logger.debug("Using authentication token from disk at #{token_path}")
+          return token_path.read.strip
+        end
+
+        if present?(ENV["ATLAS_TOKEN"])
+          @logger.warn("ATLAS_TOKEN detected within environment. Using ATLAS_TOKEN in place of VAGRANT_CLOUD_TOKEN.")
+          return ENV["ATLAS_TOKEN"]
+        end
+
+        @logger.debug("No authentication token in environment or #{token_path}")
+
+        nil
+      end
+
+      protected
+
+      def with_error_handling(&block)
+        yield
+      rescue RestClient::Unauthorized
+        @logger.debug("Unauthorized!")
+        raise Errors::Unauthorized
+      rescue RestClient::BadRequest => e
+        @logger.debug("Bad request:")
+        @logger.debug(e.message)
+        @logger.debug(e.backtrace.join("\n"))
+        parsed_response = JSON.parse(e.response)
+        errors = parsed_response["errors"].join("\n")
+        raise Errors::ServerError, errors: errors
+      rescue RestClient::NotAcceptable => e
+        @logger.debug("Got unacceptable response:")
+        @logger.debug(e.message)
+        @logger.debug(e.backtrace.join("\n"))
+
+        parsed_response = JSON.parse(e.response)
+
+        if two_factor = parsed_response['two_factor']
+          store_two_factor_information two_factor
+
+          if two_factor_default_delivery_method != APP
+            request_code two_factor_default_delivery_method
+          end
+
+          raise Errors::TwoFactorRequired
+        end
+
+        begin
+          errors = parsed_response["errors"].join("\n")
+          raise Errors::ServerError, errors: errors
+        rescue JSON::ParserError; end
+
+        raise "An unexpected error occurred: #{e.inspect}"
+      rescue SocketError
+        @logger.info("Socket error")
+        raise Errors::ServerUnreachable, url: Vagrant.server_url.to_s
+      end
+
+      def token_path
+        @env.data_dir.join("vagrant_login_token")
+      end
+
+      def store_two_factor_information(two_factor)
+        @two_factor_default_delivery_method =
+          two_factor['default_delivery_method']
+
+        @two_factor_delivery_methods =
+          two_factor['delivery_methods']
+
+        @env.ui.warn "2FA is enabled for your account."
+        if two_factor_default_delivery_method == APP
+          @env.ui.info "Enter the code from your authenticator."
+        else
+          @env.ui.info "Default method is " \
+            "'#{two_factor_default_delivery_method}'."
+        end
+
+        other_delivery_methods =
+          two_factor_delivery_methods - [APP]
+
+        if other_delivery_methods.any?
+          other_delivery_methods_sentence = other_delivery_methods
+            .map { |word| "'#{word}'" }
+            .join(' or ')
+          @env.ui.info "You can also type #{other_delivery_methods_sentence} " \
+            "to request a new code."
+        end
+      end
+    end
+  end
+end