vagrant-aws-mkubenka 0.7.2.pre.14 → 0.7.2.pre.16

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/providers/docker/provider.rb

@@ -1,205 +0,0 @@
-require "digest/md5"
-require "fileutils"
-require "thread"
-
-require "log4r"
-
-require "vagrant/util/silence_warnings"
-
-module VagrantPlugins
-  module DockerProvider
-    class Provider < Vagrant.plugin("2", :provider)
-      @@host_vm_mutex = Mutex.new
-
-      def initialize(machine)
-        @logger  = Log4r::Logger.new("vagrant::provider::docker")
-        @machine = machine
-
-        if host_vm?
-          # We need to use a special communicator that proxies our
-          # SSH requests over our host VM to the container itself.
-          @machine.config.vm.communicator = :docker_hostvm
-        end
-      end
-
-      # @see Vagrant::Plugin::V2::Provider#action
-      def action(name)
-        action_method = "action_#{name}"
-        return Action.send(action_method) if Action.respond_to?(action_method)
-        nil
-      end
-
-      # Returns the driver instance for this provider.
-      def driver
-        if !@driver
-          if @machine.provider_config.compose
-            @driver = Driver::Compose.new(@machine)
-          else
-            @driver = Driver.new
-          end
-        end
-        if host_vm?
-          @driver.executor = Executor::Vagrant.new(host_vm)
-        end
-
-        @driver
-      end
-
-      # This returns the {Vagrant::Machine} that is our host machine.
-      # It does not perform any action on the machine or verify it is
-      # running.
-      #
-      # @return [Vagrant::Machine]
-      def host_vm
-        return @host_vm if @host_vm
-
-        vf_path           = @machine.provider_config.vagrant_vagrantfile
-        host_machine_name = @machine.provider_config.vagrant_machine || :default
-        if !vf_path
-          # We don't have a Vagrantfile path set, so we're going to use
-          # the default but we need to copy it into the data dir so that
-          # we don't write into our installation dir (we can't).
-          default_path = File.expand_path("../hostmachine/Vagrantfile", __FILE__)
-          vf_path      = @machine.env.data_dir.join("docker-host", "Vagrantfile")
-          begin
-            @machine.env.lock("docker-provider-hostvm") do
-              vf_path.dirname.mkpath
-              FileUtils.cp(default_path, vf_path)
-            end
-          rescue Vagrant::Errors::EnvironmentLockedError
-            # Lock contention, just retry
-            retry
-          end
-
-          # Set the machine name since we hardcode that for the default
-          host_machine_name = :default
-        end
-
-        # Expand it so that the home directories and so on get processed
-        # properly.
-        vf_path = File.expand_path(vf_path, @machine.env.root_path)
-
-        vf_file = File.basename(vf_path)
-        vf_path = File.dirname(vf_path)
-
-        # Create the env to manage this machine
-        @host_vm = Vagrant::Util::SilenceWarnings.silence! do
-          host_env = Vagrant::Environment.new(
-            cwd: vf_path,
-            home_path: @machine.env.home_path,
-            ui_class: @machine.env.ui_class,
-            vagrantfile_name: vf_file,
-          )
-
-          # If there is no root path, then the Vagrantfile wasn't found
-          # and it is an error...
-          raise Errors::VagrantfileNotFound if !host_env.root_path
-
-          host_env.machine(
-            host_machine_name,
-            host_env.default_provider(
-              exclude: [:docker],
-              force_default: false,
-            ))
-        end
-
-        @host_vm
-      end
-
-      # This acquires a lock on the host VM.
-      def host_vm_lock
-        hash = Digest::MD5.hexdigest(host_vm.data_dir.to_s)
-
-        # We do a process-level mutex on the outside, since we can
-        # wait for that a short amount of time. Then, we do a process lock
-        # on the inside, which will raise an exception if locked.
-        host_vm_mutex.synchronize do
-          @machine.env.lock(hash) do
-            return yield
-          end
-        end
-      end
-
-      # This is a process-local mutex that can be used by parallel
-      # providers to lock the host VM access.
-      def host_vm_mutex
-        @@host_vm_mutex
-      end
-
-      # This says whether or not Docker will be running within a VM
-      # rather than directly on our system. Docker needs to run in a VM
-      # when we're not on Linux, or not on a Linux that supports Docker.
-      def host_vm?
-        @machine.provider_config.force_host_vm
-      end
-
-      # Returns the SSH info for accessing the Container.
-      def ssh_info
-        # If the container isn't running, we can't SSH into it
-        return nil if state.id != :running
-
-        port_name = "#{@machine.config.ssh.guest_port}/tcp"
-        network   = driver.inspect_container(@machine.id)['NetworkSettings']
-
-        if network["Ports"][port_name].respond_to?(:first)
-          port_info = network["Ports"][port_name].first
-        else
-          ip = network["IpAddress"]
-          port = @machine.config.ssh.guest_port
-          if !ip.to_s.empty?
-            port_info = {
-              "HostIp" => ip,
-              "HostPort" => port
-            }
-          end
-        end
-
-        # If we were not able to identify the container's IP, we return nil
-        # here and we let Vagrant core deal with it ;)
-        return nil if port_info.nil? || port_info.empty?
-
-        {
-          host: port_info['HostIp'],
-          port: port_info['HostPort']
-        }
-      end
-
-      def state
-        state_id = nil
-        state_id = :not_created if !@machine.id
-
-        begin
-          state_id = :host_state_unknown if !state_id && \
-            host_vm? && !host_vm.communicate.ready?
-        rescue Errors::VagrantfileNotFound
-          state_id = :host_state_unknown
-        end
-
-        state_id = :not_created if !state_id && \
-          (!@machine.id || !driver.created?(@machine.id))
-        state_id = driver.state(@machine.id) if @machine.id && !state_id
-        state_id = :unknown if !state_id
-
-        # This is a special pseudo-state so that we don't set the
-        # NOT_CREATED_ID while we're setting up the machine. This avoids
-        # clearing the data dir.
-        state_id = :preparing if @machine.id == "preparing"
-
-        short = state_id.to_s.gsub("_", " ")
-        long  = I18n.t("docker_provider.status.#{state_id}")
-
-        # If we're not created, then specify the special ID flag
-        if state_id == :not_created
-          state_id = Vagrant::MachineState::NOT_CREATED_ID
-        end
-
-        Vagrant::MachineState.new(state_id, short, long)
-      end
-
-      def to_s
-        id = @machine.id ? @machine.id : "new container"
-        "Docker (#{id})"
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/providers/hyperv/action/import.rb

@@ -1,177 +0,0 @@
-require "fileutils"
-
-require "log4r"
-
-module VagrantPlugins
-  module HyperV
-    module Action
-      class Import
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::hyperv::import")
-        end
-
-        def call(env)
-          vm_dir = env[:machine].box.directory.join("Virtual Machines")
-          hd_dir = env[:machine].box.directory.join("Virtual Hard Disks")
-          memory = env[:machine].provider_config.memory
-          maxmemory = env[:machine].provider_config.maxmemory
-          cpus = env[:machine].provider_config.cpus
-          vmname = env[:machine].provider_config.vmname
-          differencing_disk = env[:machine].provider_config.differencing_disk
-          auto_start_action = env[:machine].provider_config.auto_start_action
-          auto_stop_action = env[:machine].provider_config.auto_stop_action
-          enable_virtualization_extensions = env[:machine].provider_config.enable_virtualization_extensions
-          vm_integration_services = env[:machine].provider_config.vm_integration_services
-
-          env[:ui].output("Configured Dynamic memory allocation, maxmemory is #{maxmemory}") if maxmemory
-          env[:ui].output("Configured startup memory is #{memory}") if memory
-          env[:ui].output("Configured cpus number is #{cpus}") if cpus
-          env[:ui].output("Configured enable virtualization extensions is #{enable_virtualization_extensions}") if enable_virtualization_extensions
-          env[:ui].output("Configured vmname is #{vmname}") if vmname
-          env[:ui].output("Configured differencing disk instead of cloning") if differencing_disk
-          env[:ui].output("Configured automatic start action is #{auto_start_action}") if auto_start_action
-          env[:ui].output("Configured automatic stop action is #{auto_stop_action}") if auto_stop_action
-
-          if !vm_dir.directory? || !hd_dir.directory?
-            raise Errors::BoxInvalid
-          end
-
-          config_path = nil
-          config_type = nil
-          vm_dir.each_child do |f|
-            if f.extname.downcase == '.xml'
-              @logger.debug("Found XML config...")
-              config_path = f
-              config_type = 'xml'
-              break
-            end
-          end
-
-          vmcx_support = env[:machine].provider.driver.execute("has_vmcx_support.ps1", {})
-          if vmcx_support
-            vm_dir.each_child do |f|
-              if f.extname.downcase == '.vmcx'
-                @logger.debug("Found VMCX config and support...")
-                config_path = f
-                config_type = 'vmcx'
-                break
-              end
-            end
-          end
-
-          image_path = nil
-          image_ext = nil
-          image_filename = nil
-          hd_dir.each_child do |f|
-            if %w{.vhd .vhdx}.include?(f.extname.downcase)
-              image_path = f
-              image_ext = f.extname.downcase
-              image_filename = File.basename(f, image_ext)
-              break
-            end
-          end
-
-          if !config_path || !image_path
-            raise Errors::BoxInvalid
-          end
-
-          env[:ui].output("Importing a Hyper-V instance")
-
-          switches = env[:machine].provider.driver.execute("get_switches.ps1", {})
-          raise Errors::NoSwitches if switches.empty?
-
-          switch = nil
-          env[:machine].config.vm.networks.each do |type, opts|
-            next if type != :public_network && type != :private_network
-
-            switchToFind = opts[:bridge]
-
-            if switchToFind
-              puts "Looking for switch with name: #{switchToFind}"
-              switch = switches.find { |s| s["Name"].downcase == switchToFind.downcase }["Name"]
-              puts "Found switch: #{switch}"
-            end
-          end
-
-          if switch.nil?
-            if switches.length > 1
-              env[:ui].detail(I18n.t("vagrant_hyperv.choose_switch") + "\n ")
-              switches.each_index do |i|
-                switch = switches[i]
-                env[:ui].detail("#{i+1}) #{switch["Name"]}")
-              end
-              env[:ui].detail(" ")
-
-              switch = nil
-              while !switch
-                switch = env[:ui].ask("What switch would you like to use? ")
-                next if !switch
-                switch = switch.to_i - 1
-                switch = nil if switch < 0 || switch >= switches.length
-              end
-              switch = switches[switch]["Name"]
-            else
-              switch = switches[0]["Name"]
-            end
-          end
-
-          env[:ui].detail("Cloning virtual hard drive...")
-          source_path = image_path.to_s
-          dest_path = env[:machine].data_dir.join("Virtual Hard Disks").join("#{image_filename}#{image_ext}").to_s
-
-          # Still hard copy the disk of old XML configurations
-          if config_type == 'xml'
-            if differencing_disk
-              env[:machine].provider.driver.execute("clone_vhd.ps1", {Source: source_path, Destination: dest_path})
-            else
-              FileUtils.mkdir_p(env[:machine].data_dir.join("Virtual Hard Disks"))
-              FileUtils.cp(source_path, dest_path)
-            end
-          end
-          image_path = dest_path
-
-          # We have to normalize the paths to be Windows paths since
-          # we're executing PowerShell.
-          options = {
-              vm_config_file: config_path.to_s.gsub("/", "\\"),
-              vm_config_type: config_type,
-              source_path:    source_path.to_s,
-              dest_path:      dest_path,
-              data_path:      env[:machine].data_dir.to_s.gsub("/", "\\")
-          }
-          options[:switchname] = switch if switch
-          options[:memory] = memory if memory
-          options[:maxmemory] = maxmemory if maxmemory
-          options[:cpus] = cpus if cpus
-          options[:vmname] = vmname if vmname
-          options[:auto_start_action] = auto_start_action if auto_start_action
-          options[:auto_stop_action] = auto_stop_action if auto_stop_action
-          options[:differencing_disk] = differencing_disk if differencing_disk
-          options[:enable_virtualization_extensions] = "$True" if enable_virtualization_extensions and enable_virtualization_extensions == true
-
-          env[:ui].detail("Creating and registering the VM...")
-          server = env[:machine].provider.driver.import(options)
-
-          env[:ui].detail("Setting VM Integration Services")
-          vm_integration_services.each do |key, value|
-            state = false
-            if value === true
-              state = "enabled"
-            elsif value === false
-              state = "disabled"
-            end
-            env[:ui].output("#{key} is #{state}") if state
-          end
-
-          vm_integration_services[:VmId] = server["id"]
-          env[:machine].provider.driver.set_vm_integration_services(vm_integration_services)
-
-          env[:ui].detail("Successfully imported a VM with name: #{server['name']}")
-          env[:machine].id = server["id"]
-          @app.call(env)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/providers/hyperv/action/wait_for_ip_address.rb

@@ -1,55 +0,0 @@
-require "ipaddr"
-require "timeout"
-
-module VagrantPlugins
-  module HyperV
-    module Action
-      class WaitForIPAddress
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::hyperv::wait_for_ip_addr")
-        end
-
-        def call(env)
-          timeout = env[:machine].provider_config.ip_address_timeout
-
-          env[:ui].output("Waiting for the machine to report its IP address...")
-          env[:ui].detail("Timeout: #{timeout} seconds")
-
-          guest_ip = nil
-          Timeout.timeout(timeout) do
-            while true
-              # If a ctrl-c came through, break out
-              return if env[:interrupted]
-
-              # Try to get the IP
-              network_info = env[:machine].provider.driver.read_guest_ip
-              guest_ip = network_info["ip"]
-
-              if guest_ip
-                begin
-                  IPAddr.new(guest_ip)
-                  break
-                rescue IPAddr::InvalidAddressError
-                  # Ignore, continue looking.
-                  @logger.warn("Invalid IP address returned: #{guest_ip}")
-                end
-              end
-
-              sleep 1
-            end
-          end
-
-          # If we were interrupted then return now
-          return if env[:interrupted]
-
-          env[:ui].detail("IP: #{guest_ip}")
-
-          @app.call(env)
-        rescue Timeout::Error
-          raise Errors::IPAddrTimeout
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/providers/hyperv/scripts/get_network_config.ps1

@@ -1,27 +0,0 @@
-Param(
-    [Parameter(Mandatory=$true)]
-    [string]$VmId
- )
-
-# Include the following modules
-$Dir = Split-Path $script:MyInvocation.MyCommand.Path
-. ([System.IO.Path]::Combine($Dir, "utils\write_messages.ps1"))
-
-$ip_address = ""
-$vm = Get-VM -Id $VmId -ErrorAction "Stop"
-$networks = Get-VMNetworkAdapter -VM $vm
-foreach ($network in $networks) {
-  if ($network.IpAddresses.Length -gt 0) {
-    $ip_address = $network.IpAddresses[0]
-    if (-Not ([string]::IsNullOrEmpty($ip_address))) {
-      # We found our IP address!
-      break
-    }
-  }
-}
-
-$resultHash = @{
-    ip = "$ip_address"
-}
-$result = ConvertTo-Json $resultHash
-Write-Output-Message $result

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-5333e60e2d38/plugins/providers/virtualbox/action/prepare_nfs_settings.rb

@@ -1,141 +0,0 @@
-require "vagrant/action/builtin/mixin_synced_folders"
-
-module VagrantPlugins
-  module ProviderVirtualBox
-    module Action
-      class PrepareNFSSettings
-        include Vagrant::Action::Builtin::MixinSyncedFolders
-        include Vagrant::Util::Retryable
-
-        def initialize(app, env)
-          @app = app
-          @logger = Log4r::Logger.new("vagrant::action::vm::nfs")
-        end
-
-        def call(env)
-          @machine = env[:machine]
-
-          @app.call(env)
-
-          opts = {
-            cached: !!env[:synced_folders_cached],
-            config: env[:synced_folders_config],
-            disable_usable_check: !!env[:test],
-          }
-          folders = synced_folders(env[:machine], **opts)
-
-          if folders.key?(:nfs)
-            @logger.info("Using NFS, preparing NFS settings by reading host IP and machine IP")
-            add_ips_to_env!(env)
-          end
-        end
-
-        # Extracts the proper host and guest IPs for NFS mounts and stores them
-        # in the environment for the SyncedFolder action to use them in
-        # mounting.
-        #
-        # The ! indicates that this method modifies its argument.
-        def add_ips_to_env!(env)
-          adapter, host_ip = find_host_only_adapter
-          machine_ip       = read_static_machine_ips
-
-          if !machine_ip
-            # No static IP, attempt to use the dynamic IP.
-            machine_ip = read_dynamic_machine_ip(adapter)
-          else
-            # We have static IPs, also attempt to read any dynamic IPs.
-            # If there is no dynamic IP on the adapter, it doesn't matter. We
-            # already have a static IP.
-            begin
-              dynamic_ip = read_dynamic_machine_ip(adapter)
-            rescue Vagrant::Errors::NFSNoGuestIP
-              dynamic_ip = nil
-            end
-
-            # If we found a dynamic IP and we didn't include it in the
-            # machine_ip array yet, do so.
-            if dynamic_ip && !machine_ip.include?(dynamic_ip)
-              machine_ip.push(dynamic_ip)
-            end
-          end
-
-          raise Vagrant::Errors::NFSNoHostonlyNetwork if !host_ip || !machine_ip
-
-          env[:nfs_host_ip]    = host_ip
-          env[:nfs_machine_ip] = machine_ip
-        end
-
-        # Finds first host only network adapter and returns its adapter number
-        # and IP address
-        #
-        # @return [Integer, String] adapter number, ip address of found host-only adapter
-        def find_host_only_adapter
-          @machine.provider.driver.read_network_interfaces.each do |adapter, opts|
-            if opts[:type] == :hostonly
-              @machine.provider.driver.read_host_only_interfaces.each do |interface|
-                if interface[:name] == opts[:hostonly]
-                  return adapter, interface[:ip]
-                end
-              end
-            end
-          end
-
-          nil
-        end
-
-        # Returns the IP address(es) of the guest by looking for static IPs
-        # given to host only adapters in the Vagrantfile
-        #
-        # @return [Array]<String> Configured static IPs
-        def read_static_machine_ips
-          ips = []
-          @machine.config.vm.networks.each do |type, options|
-            options = scoped_hash_override(options, :virtualbox)
-
-            if type == :private_network && options[:type] != :dhcp && options[:ip].is_a?(String)
-              ips << options[:ip]
-            end
-          end
-
-          if ips.empty?
-            return nil
-          end
-
-          ips
-        end
-
-        # Returns the IP address of the guest by looking at vbox guest property
-        # for the appropriate guest adapter.
-        #
-        # For DHCP interfaces, the guest property will not be present until the
-        # guest completes
-        #
-        # @param [Integer] adapter number to read IP for
-        # @return [String] ip address of adapter
-        def read_dynamic_machine_ip(adapter)
-          return nil unless adapter
-
-          # vbox guest properties are 0-indexed, while showvminfo network
-          # interfaces are 1-indexed. go figure.
-          guestproperty_adapter = adapter - 1
-
-          # we need to wait for the guest's IP to show up as a guest property.
-          # retry thresholds are relatively high since we might need to wait
-          # for DHCP, but even static IPs can take a second or two to appear.
-          retryable(retry_options.merge(on: Vagrant::Errors::VirtualBoxGuestPropertyNotFound)) do
-            @machine.provider.driver.read_guest_ip(guestproperty_adapter)
-          end
-        rescue Vagrant::Errors::VirtualBoxGuestPropertyNotFound
-          # this error is more specific with a better error message directing
-          # the user towards the fact that it's probably a reportable bug
-          raise Vagrant::Errors::NFSNoGuestIP
-        end
-
-        # Separating these out so we can stub out the sleep in tests
-        def retry_options
-          {tries: 15, sleep: 1}
-        end
-      end
-    end
-  end
-end