class VagrantPlugins::ProviderLibvirt::Action::WaitTillUp

Wait till domain is started, till it obtains an IP address and is accessible via ssh.

Public Class Methods

new(app, _env) click to toggle source
# File lib/vagrant-libvirt/action/wait_till_up.rb, line 14
def initialize(app, _env)
  @logger = Log4r::Logger.new('vagrant_libvirt::action::wait_till_up')
  @app = app
end

Public Instance Methods

call(env) click to toggle source
# File lib/vagrant-libvirt/action/wait_till_up.rb, line 19
def call(env)
  # Initialize metrics if they haven't been
  env[:metrics] ||= {}

  # Get domain object
  domain = env[:machine].provider.driver.get_domain(env[:machine].id.to_s)
  if domain.nil?
    raise Errors::NoDomainError,
          error_message: "Domain #{env[:machine].id} not found"
  end

  # Wait for domain to obtain an ip address. Ip address is searched
  # from arp table, either localy or remotely via ssh, if libvirt
  # connection was done via ssh.
  env[:ip_address] = nil
  env[:metrics]['instance_ip_time'] = Util::Timer.time do
    @logger.debug("Searching for IP for MAC address: #{domain.mac}")
    env[:ui].info(I18n.t('vagrant_libvirt.waiting_for_ip'))
    retryable(on: Fog::Errors::TimeoutError, tries: 300) do
      # If we're interrupted don't worry about waiting
      return terminate(env) if env[:interrupted]

      # Wait for domain to obtain an ip address
      domain.wait_for(2) do
        addresses.each_pair do |_type, ip|
          env[:ip_address] = ip[0] unless ip[0].nil?
        end
        !env[:ip_address].nil?
      end
    end
  end
  @logger.info("Got IP address #{env[:ip_address]}")
  @logger.info("Time for getting IP: #{env[:metrics]['instance_ip_time']}")

  # Machine has ip address assigned, now wait till we are able to
  # connect via ssh.
  env[:metrics]['instance_ssh_time'] = Util::Timer.time do
    env[:ui].info(I18n.t('vagrant_libvirt.waiting_for_ssh'))
    retryable(on: Fog::Errors::TimeoutError, tries: 60) do
      # If we're interrupted don't worry about waiting
      next if env[:interrupted]

      # Wait till we are able to connect via ssh.
      loop do
        # If we're interrupted then just back out
        break if env[:interrupted]
        break if env[:machine].communicate.ready?
        sleep 2
      end
    end
  end
  # if interrupted above, just terminate immediately
  return terminate(env) if env[:interrupted]
  @logger.info("Time for SSH ready: #{env[:metrics]['instance_ssh_time']}")

  # Booted and ready for use.
  # env[:ui].info(I18n.t("vagrant_libvirt.ready"))

  @app.call(env)
end
recover(env) click to toggle source
# File lib/vagrant-libvirt/action/wait_till_up.rb, line 80
def recover(env)
  return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)

  # Undo the import
  terminate(env)
end
terminate(env) click to toggle source
# File lib/vagrant-libvirt/action/wait_till_up.rb, line 87
def terminate(env)
  if env[:machine].provider.state.id != :not_created
    # If we're not supposed to destroy on error then just return
    return unless env[:destroy_on_error]

    if env[:halt_on_error]
      halt_env = env.dup
      halt_env.delete(:interrupted)
      halt_env[:config_validate] = false
      env[:action_runner].run(Action.action_halt, halt_env)
    else
      destroy_env = env.dup
      destroy_env.delete(:interrupted)
      destroy_env[:config_validate] = false
      destroy_env[:force_confirm_destroy] = true
      env[:action_runner].run(Action.action_destroy, destroy_env)
    end
  end
end