Class: VagrantPlugins::OVirtProvider::Action::CreateVM

Inherits:
Object
  • Object
show all
Includes:
Vagrant::Util::Retryable
Defined in:
lib/vagrant-ovirt3/action/create_vm.rb

Instance Method Summary collapse

Constructor Details

#initialize(app, env) ⇒ CreateVM

Returns a new instance of CreateVM.



10
11
12
13
 
# File 'lib/vagrant-ovirt3/action/create_vm.rb', line 10

def initialize(app, env)
  @logger = Log4r::Logger.new("vagrant_ovirt3::action::create_vm")
  @app = app
end

Instance Method Details

#call(env) ⇒ Object

Raises:



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/vagrant-ovirt3/action/create_vm.rb', line 15

def call(env)
  # Get config.
  config = env[:machine].provider_config

  # Gather some info about domain
  name = (config.name.nil? ? env[:domain_name] : config.name)[0,15]
  console = config.console
  cpus = config.cpus
  memory_guaranteed_size = config.memory_guaranteed ? config.memory_guaranteed*1024 : nil
  quota = config.quota
  memory_size = config.memory*1024
  connect_timeout = config.connect_timeout
  user_data = config.user_data ?
    Base64::encode64(config.user_data) :
    nil

  # Get cluster
  if config.cluster == nil
    cluster = env[:ovirt_compute].clusters.first
  else
    cluster = OVirtProvider::Util::Collection.find_matching(
      env[:ovirt_compute].clusters.all, config.cluster)
  end
  raise Errors::NoClusterError if cluster == nil
  # TODO fill env also with other ovirtoptions.
  env[:ovirt_cluster] = cluster

  # Get template
  template = env[:ovirt_compute].templates.all.find_all { |t|
    t.id == config.template or t.name == config.template
  }
  .sort_by { |t| t.raw.version.version_number.to_i }.reverse
  .find { |t|
    v = t.raw.version
    cv = config.template_version
    cv.nil? or (cv.to_i == v.version_number.to_i or cv == v.version_name)
  }
  if template == nil
    raise Errors::NoTemplateError,
      :template_name => config.template
  end
  ver = template.raw.version
  if !ver.version_name.nil? and !ver.version_name.empty?
    version_string = "#{ver.version_name} (#{ver.version_number.to_i})"
  else
    version_string = "#{ver.version_number.to_i}"
  end

  # Output the settings we're going to use to the user
  env[:ui].info(I18n.t("vagrant_ovirt3.creating_vm"))
  env[:ui].info(" -- Name:              #{name}")
  env[:ui].info(" -- Cpus:              #{cpus}")
  env[:ui].info(" -- Memory:            #{memory_size/1024}M")
  env[:ui].info(" -- Template:          #{template.name}")
  env[:ui].info(" -- Version:           #{version_string}")
  env[:ui].info(" -- Datacenter:        #{config.datacenter}")
  env[:ui].info(" -- Cluster:           #{cluster.name}")
  env[:ui].info(" -- Console:           #{console}")
  if memory_guaranteed_size
    env[:ui].info(" -- Memory Guaranteed: #{memory_guaranteed_size/1024}M")
  end
  if quota
    env[:ui].info(" -- Quota:           #{quota}")
  end
  if config.disk_size
    env[:ui].info(" -- Disk size:       #{config.disk_size}G")
  end
  if config.user_data
    env[:ui].info(" -- User data:\n#{config.user_data}")
  end

  # Create oVirt VM.
  attr = {
      :name               => name,
      :cores              => cpus,
      :memory             => memory_size*1024,
      :cluster            => cluster.id,
      :template           => template.id,
      :display            => {:type => console },
      :user_data          => user_data,
      :quota              => quota,
      :memory_guaranteed  => memory_guaranteed_size,
  }

  begin
    server = env[:ovirt_compute].servers.create(attr)
  rescue OVIRT::OvirtException => e
    raise Errors::FogCreateServerError,
      :error_message => e.message
  end

  # Immediately save the ID since it is created at this point.
  env[:machine].id = server.id

  # Wait till all volumes are ready.
  env[:ui].info(I18n.t("vagrant_ovirt3.wait_for_ready_vm"))
  for i in 0..connect_timeout
    ready = true
    server = env[:ovirt_compute].servers.get(env[:machine].id.to_s)
    server.volumes.each do |volume|
      if volume.status != 'ok'
        ready = false
        break
      end
    end
    if env[:machine].state.id != :down
      ready = false
    end
    break if ready
    sleep 2
  end

  if not ready
    raise Errors::WaitForReadyVmTimeout
  end

  @app.call(env)
end

#recover(env) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/vagrant-ovirt3/action/create_vm.rb', line 134

def recover(env)
  return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)

  # Undo the import
  env[:ui].info(I18n.t("vagrant_ovirt3.error_recovering"))
  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