Statistics
| Branch: | Tag: | Revision:

root / lib / hypervisor / hv_kvm.py @ c087266c

History | View | Annotate | Download (20.6 kB)

1
#
2
#
3

    
4
# Copyright (C) 2008 Google Inc.
5
#
6
# This program is free software; you can redistribute it and/or modify
7
# it under the terms of the GNU General Public License as published by
8
# the Free Software Foundation; either version 2 of the License, or
9
# (at your option) any later version.
10
#
11
# This program is distributed in the hope that it will be useful, but
12
# WITHOUT ANY WARRANTY; without even the implied warranty of
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
# General Public License for more details.
15
#
16
# You should have received a copy of the GNU General Public License
17
# along with this program; if not, write to the Free Software
18
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19
# 02110-1301, USA.
20

    
21

    
22
"""KVM hypervisor
23

24
"""
25

    
26
import os
27
import os.path
28
import re
29
import tempfile
30
import time
31
import logging
32
from cStringIO import StringIO
33

    
34
from ganeti import utils
35
from ganeti import constants
36
from ganeti import errors
37
from ganeti import serializer
38
from ganeti import objects
39
from ganeti.hypervisor import hv_base
40

    
41

    
42
class KVMHypervisor(hv_base.BaseHypervisor):
43
  """KVM hypervisor interface"""
44

    
45
  _ROOT_DIR = constants.RUN_GANETI_DIR + "/kvm-hypervisor"
46
  _PIDS_DIR = _ROOT_DIR + "/pid" # contains live instances pids
47
  _CTRL_DIR = _ROOT_DIR + "/ctrl" # contains instances control sockets
48
  _CONF_DIR = _ROOT_DIR + "/conf" # contains instances startup data
49
  _DIRS = [_ROOT_DIR, _PIDS_DIR, _CTRL_DIR, _CONF_DIR]
50

    
51
  PARAMETERS = [
52
    constants.HV_KERNEL_PATH,
53
    constants.HV_INITRD_PATH,
54
    constants.HV_ACPI,
55
    ]
56

    
57
  _MIGRATION_STATUS_RE = re.compile('Migration\s+status:\s+(\w+)',
58
                                    re.M | re.I)
59

    
60
  def __init__(self):
61
    hv_base.BaseHypervisor.__init__(self)
62
    # Let's make sure the directories we need exist, even if the RUN_DIR lives
63
    # in a tmpfs filesystem or has been otherwise wiped out.
64
    for mydir in self._DIRS:
65
      if not os.path.exists(mydir):
66
        os.mkdir(mydir)
67

    
68
  def _InstancePidAlive(self, instance_name):
69
    """Returns the instance pid and pidfile
70

71
    """
72
    pidfile = "%s/%s" % (self._PIDS_DIR, instance_name)
73
    pid = utils.ReadPidFile(pidfile)
74
    alive = utils.IsProcessAlive(pid)
75

    
76
    return (pidfile, pid, alive)
77

    
78
  def _InstanceMonitor(self, instance_name):
79
    """Returns the instance monitor socket name
80

81
    """
82
    return '%s/%s.monitor' % (self._CTRL_DIR, instance_name)
83

    
84
  def _InstanceSerial(self, instance_name):
85
    """Returns the instance serial socket name
86

87
    """
88
    return '%s/%s.serial' % (self._CTRL_DIR, instance_name)
89

    
90
  def _InstanceKVMRuntime(self, instance_name):
91
    """Returns the instance KVM runtime filename
92

93
    """
94
    return '%s/%s.runtime' % (self._CONF_DIR, instance_name)
95

    
96
  def _WriteNetScript(self, instance, seq, nic):
97
    """Write a script to connect a net interface to the proper bridge.
98

99
    This can be used by any qemu-type hypervisor.
100

101
    @param instance: instance we're acting on
102
    @type instance: instance object
103
    @param seq: nic sequence number
104
    @type seq: int
105
    @param nic: nic we're acting on
106
    @type nic: nic object
107
    @return: netscript file name
108
    @rtype: string
109

110
    """
111
    script = StringIO()
112
    script.write("#!/bin/sh\n")
113
    script.write("# this is autogenerated by Ganeti, please do not edit\n#\n")
114
    script.write("export INSTANCE=%s\n" % instance.name)
115
    script.write("export MAC=%s\n" % nic.mac)
116
    script.write("export IP=%s\n" % nic.ip)
117
    script.write("export BRIDGE=%s\n" % nic.bridge)
118
    script.write("export INTERFACE=$1\n")
119
    # TODO: make this configurable at ./configure time
120
    script.write("if [ -x /etc/ganeti/kvm-vif-bridge ]; then\n")
121
    script.write("  # Execute the user-specific vif file\n")
122
    script.write("  /etc/ganeti/kvm-vif-bridge\n")
123
    script.write("else\n")
124
    script.write("  # Connect the interface to the bridge\n")
125
    script.write("  /sbin/ifconfig $INTERFACE 0.0.0.0 up\n")
126
    script.write("  /usr/sbin/brctl addif $BRIDGE $INTERFACE\n")
127
    script.write("fi\n\n")
128
    # As much as we'd like to put this in our _ROOT_DIR, that will happen to be
129
    # mounted noexec sometimes, so we'll have to find another place.
130
    (tmpfd, tmpfile_name) = tempfile.mkstemp()
131
    tmpfile = os.fdopen(tmpfd, 'w')
132
    tmpfile.write(script.getvalue())
133
    tmpfile.close()
134
    os.chmod(tmpfile_name, 0755)
135
    return tmpfile_name
136

    
137
  def ListInstances(self):
138
    """Get the list of running instances.
139

140
    We can do this by listing our live instances directory and
141
    checking whether the associated kvm process is still alive.
142

143
    """
144
    result = []
145
    for name in os.listdir(self._PIDS_DIR):
146
      filename = "%s/%s" % (self._PIDS_DIR, name)
147
      if utils.IsProcessAlive(utils.ReadPidFile(filename)):
148
        result.append(name)
149
    return result
150

    
151
  def GetInstanceInfo(self, instance_name):
152
    """Get instance properties.
153

154
    @param instance_name: the instance name
155

156
    @return: tuple (name, id, memory, vcpus, stat, times)
157

158
    """
159
    pidfile, pid, alive = self._InstancePidAlive(instance_name)
160
    if not alive:
161
      return None
162

    
163
    cmdline_file = "/proc/%s/cmdline" % pid
164
    try:
165
      fh = open(cmdline_file, 'r')
166
      try:
167
        cmdline = fh.read()
168
      finally:
169
        fh.close()
170
    except EnvironmentError, err:
171
      raise errors.HypervisorError("Failed to list instance %s: %s" %
172
                                   (instance_name, err))
173

    
174
    memory = 0
175
    vcpus = 0
176
    stat = "---b-"
177
    times = "0"
178

    
179
    arg_list = cmdline.split('\x00')
180
    while arg_list:
181
      arg =  arg_list.pop(0)
182
      if arg == '-m':
183
        memory = arg_list.pop(0)
184
      elif arg == '-smp':
185
        vcpus = arg_list.pop(0)
186

    
187
    return (instance_name, pid, memory, vcpus, stat, times)
188

    
189
  def GetAllInstancesInfo(self):
190
    """Get properties of all instances.
191

192
    @return: list of tuples (name, id, memory, vcpus, stat, times)
193

194
    """
195
    data = []
196
    for name in os.listdir(self._PIDS_DIR):
197
      filename = "%s/%s" % (self._PIDS_DIR, name)
198
      if utils.IsProcessAlive(utils.ReadPidFile(filename)):
199
        data.append(self.GetInstanceInfo(name))
200

    
201
    return data
202

    
203
  def _GenerateKVMRuntime(self, instance, block_devices, extra_args):
204
    """Generate KVM information to start an instance.
205

206
    """
207
    pidfile, pid, alive = self._InstancePidAlive(instance.name)
208
    kvm = constants.KVM_PATH
209
    kvm_cmd = [kvm]
210
    kvm_cmd.extend(['-m', instance.beparams[constants.BE_MEMORY]])
211
    kvm_cmd.extend(['-smp', instance.beparams[constants.BE_VCPUS]])
212
    kvm_cmd.extend(['-pidfile', pidfile])
213
    # used just by the vnc server, if enabled
214
    kvm_cmd.extend(['-name', instance.name])
215
    kvm_cmd.extend(['-daemonize'])
216
    if not instance.hvparams[constants.HV_ACPI]:
217
      kvm_cmd.extend(['-no-acpi'])
218

    
219
    boot_drive = True
220
    for cfdev, dev_path in block_devices:
221
      # TODO: handle FD_LOOP and FD_BLKTAP (?)
222
      if boot_drive:
223
        boot_val = ',boot=on'
224
        boot_drive = False
225
      else:
226
        boot_val = ''
227

    
228
      # TODO: handle different if= types
229
      if_val = ',if=virtio'
230

    
231
      drive_val = 'file=%s,format=raw%s%s' % (dev_path, if_val, boot_val)
232
      kvm_cmd.extend(['-drive', drive_val])
233

    
234
    kvm_cmd.extend(['-kernel', instance.hvparams[constants.HV_KERNEL_PATH]])
235

    
236
    initrd_path = instance.hvparams[constants.HV_INITRD_PATH]
237
    if initrd_path:
238
      kvm_cmd.extend(['-initrd', initrd_path])
239

    
240
    kvm_cmd.extend(['-append', 'console=ttyS0,38400 root=/dev/vda'])
241

    
242
    #"hvm_boot_order",
243
    #"hvm_cdrom_image_path",
244

    
245
    kvm_cmd.extend(['-nographic'])
246
    # FIXME: handle vnc, if needed
247
    # How do we decide whether to have it or not?? :(
248
    #"vnc_bind_address",
249
    #"network_port"
250
    monitor_dev = 'unix:%s,server,nowait' % \
251
      self._InstanceMonitor(instance.name)
252
    kvm_cmd.extend(['-monitor', monitor_dev])
253
    serial_dev = 'unix:%s,server,nowait' % self._InstanceSerial(instance.name)
254
    kvm_cmd.extend(['-serial', serial_dev])
255

    
256
    # Save the current instance nics, but defer their expansion as parameters,
257
    # as we'll need to generate executable temp files for them.
258
    kvm_nics = instance.nics
259

    
260
    return (kvm_cmd, kvm_nics)
261

    
262
  def _WriteKVMRuntime(self, instance_name, data):
263
    """Write an instance's KVM runtime
264

265
    """
266
    try:
267
      utils.WriteFile(self._InstanceKVMRuntime(instance_name),
268
                      data=data)
269
    except EnvironmentError, err:
270
      raise errors.HypervisorError("Failed to save KVM runtime file: %s" % err)
271

    
272
  def _ReadKVMRuntime(self, instance_name):
273
    """Read an instance's KVM runtime
274

275
    """
276
    try:
277
      file_content = utils.ReadFile(self._InstanceKVMRuntime(instance_name))
278
    except EnvironmentError, err:
279
      raise errors.HypervisorError("Failed to load KVM runtime file: %s" % err)
280
    return file_content
281

    
282
  def _SaveKVMRuntime(self, instance, kvm_runtime):
283
    """Save an instance's KVM runtime
284

285
    """
286
    kvm_cmd, kvm_nics = kvm_runtime
287
    serialized_nics = [nic.ToDict() for nic in kvm_nics]
288
    serialized_form = serializer.Dump((kvm_cmd, serialized_nics))
289
    self._WriteKVMRuntime(instance.name, serialized_form)
290

    
291
  def _LoadKVMRuntime(self, instance, serialized_runtime=None):
292
    """Load an instance's KVM runtime
293

294
    """
295
    if not serialized_runtime:
296
      serialized_runtime = self._ReadKVMRuntime(instance.name)
297
    loaded_runtime = serializer.Load(serialized_runtime)
298
    kvm_cmd, serialized_nics = loaded_runtime
299
    kvm_nics = [objects.NIC.FromDict(snic) for snic in serialized_nics]
300
    return (kvm_cmd, kvm_nics)
301

    
302
  def _ExecuteKVMRuntime(self, instance, kvm_runtime, incoming=None):
303
    """Execute a KVM cmd, after completing it with some last minute data
304

305
    @type incoming: tuple of strings
306
    @param incoming: (target_host_ip, port)
307

308
    """
309
    pidfile, pid, alive = self._InstancePidAlive(instance.name)
310
    if alive:
311
      raise errors.HypervisorError("Failed to start instance %s: %s" %
312
                                   (instance.name, "already running"))
313

    
314
    temp_files = []
315

    
316
    kvm_cmd, kvm_nics = kvm_runtime
317

    
318
    if not kvm_nics:
319
      kvm_cmd.extend(['-net', 'none'])
320
    else:
321
      for nic_seq, nic in enumerate(kvm_nics):
322
        nic_val = "nic,macaddr=%s,model=virtio" % nic.mac
323
        script = self._WriteNetScript(instance, nic_seq, nic)
324
        kvm_cmd.extend(['-net', nic_val])
325
        kvm_cmd.extend(['-net', 'tap,script=%s' % script])
326
        temp_files.append(script)
327

    
328
    if incoming:
329
      target, port = incoming
330
      kvm_cmd.extend(['-incoming', 'tcp:%s:%s' % (target, port)])
331

    
332
    result = utils.RunCmd(kvm_cmd)
333
    if result.failed:
334
      raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
335
                                   (instance.name, result.fail_reason,
336
                                    result.output))
337

    
338
    if not utils.IsProcessAlive(utils.ReadPidFile(pidfile)):
339
      raise errors.HypervisorError("Failed to start instance %s: %s" %
340
                                   (instance.name))
341

    
342
    for filename in temp_files:
343
      utils.RemoveFile(filename)
344

    
345
  def StartInstance(self, instance, block_devices, extra_args):
346
    """Start an instance.
347

348
    """
349
    pidfile, pid, alive = self._InstancePidAlive(instance.name)
350
    if alive:
351
      raise errors.HypervisorError("Failed to start instance %s: %s" %
352
                                   (instance.name, "already running"))
353

    
354
    kvm_runtime = self._GenerateKVMRuntime(instance, block_devices, extra_args)
355
    self._SaveKVMRuntime(instance, kvm_runtime)
356
    self._ExecuteKVMRuntime(instance, kvm_runtime)
357

    
358
  def _CallMonitorCommand(self, instance_name, command):
359
    """Invoke a command on the instance monitor.
360

361
    """
362
    socat = ("echo %s | %s STDIO UNIX-CONNECT:%s" %
363
             (utils.ShellQuote(command),
364
              constants.SOCAT_PATH,
365
              utils.ShellQuote(self._InstanceMonitor(instance_name))))
366
    result = utils.RunCmd(socat)
367
    if result.failed:
368
      msg = ("Failed to send command '%s' to instance %s."
369
             " output: %s, error: %s, fail_reason: %s" %
370
             (instance.name, result.stdout, result.stderr, result.fail_reason))
371
      raise errors.HypervisorError(msg)
372

    
373
    return result
374

    
375
  def _RetryInstancePowerdown(self, instance, pid, timeout=30):
376
    """Wait for an instance  to power down.
377

378
    """
379
    # Wait up to $timeout seconds
380
    end = time.time() + timeout
381
    wait = 1
382
    while time.time() < end and utils.IsProcessAlive(pid):
383
      self._CallMonitorCommand(instance.name, 'system_powerdown')
384
      time.sleep(wait)
385
      # Make wait time longer for next try
386
      if wait < 5:
387
        wait *= 1.3
388

    
389
  def StopInstance(self, instance, force=False):
390
    """Stop an instance.
391

392
    """
393
    pidfile, pid, alive = self._InstancePidAlive(instance.name)
394
    if pid > 0 and alive:
395
      if force or not instance.hvparams[constants.HV_ACPI]:
396
        utils.KillProcess(pid)
397
      else:
398
        self._RetryInstancePowerdown(instance, pid)
399

    
400
    if not utils.IsProcessAlive(pid):
401
      utils.RemoveFile(pidfile)
402
      utils.RemoveFile(self._InstanceMonitor(instance.name))
403
      utils.RemoveFile(self._InstanceSerial(instance.name))
404
      utils.RemoveFile(self._InstanceKVMRuntime(instance.name))
405
      return True
406
    else:
407
      return False
408

    
409
  def RebootInstance(self, instance):
410
    """Reboot an instance.
411

412
    """
413
    # For some reason if we do a 'send-key ctrl-alt-delete' to the control
414
    # socket the instance will stop, but now power up again. So we'll resort
415
    # to shutdown and restart.
416
    pidfile, pid, alive = self._InstancePidAlive(instance.name)
417
    if not alive:
418
      raise errors.HypervisorError("Failed to reboot instance %s: not running" %
419
                                             (instance.name))
420
    # StopInstance will delete the saved KVM runtime so:
421
    # ...first load it...
422
    kvm_runtime = self._LoadKVMRuntime(instance)
423
    # ...now we can safely call StopInstance...
424
    if not self.StopInstance(instance):
425
      self.StopInstance(instance, force=True)
426
    # ...and finally we can save it again, and execute it...
427
    self._SaveKVMRuntime(instance, kvm_runtime)
428
    self._ExecuteKVMRuntime(instance, kvm_runtime)
429

    
430
  def MigrationInfo(self, instance):
431
    """Get instance information to perform a migration.
432

433
    @type instance: L{objects.Instance}
434
    @param instance: instance to be migrated
435
    @rtype: string
436
    @return: content of the KVM runtime file
437

438
    """
439
    return self._ReadKVMRuntime(instance.name)
440

    
441
  def AcceptInstance(self, instance, info, target):
442
    """Prepare to accept an instance.
443

444
    @type instance: L{objects.Instance}
445
    @param instance: instance to be accepted
446
    @type info: string
447
    @param info: content of the KVM runtime file on the source node
448
    @type target: string
449
    @param target: target host (usually ip), on this node
450

451
    """
452
    kvm_runtime = self._LoadKVMRuntime(instance, serialized_runtime=info)
453
    incoming_address = (target, constants.KVM_MIGRATION_PORT)
454
    self._ExecuteKVMRuntime(instance, kvm_runtime, incoming=incoming_address)
455

    
456
  def FinalizeMigration(self, instance, info, success):
457
    """Finalize an instance migration.
458

459
    Stop the incoming mode KVM.
460

461
    @type instance: L{objects.Instance}
462
    @param instance: instance whose migration is being aborted
463

464
    """
465
    if success:
466
      self._WriteKVMRuntime(instance.name, info)
467
    else:
468
      self.StopInstance(instance, force=True)
469

    
470
  def MigrateInstance(self, instance_name, target, live):
471
    """Migrate an instance to a target node.
472

473
    The migration will not be attempted if the instance is not
474
    currently running.
475

476
    @type instance_name: string
477
    @param instance_name: name of the instance to be migrated
478
    @type target: string
479
    @param target: ip address of the target node
480
    @type live: boolean
481
    @param live: perform a live migration
482

483
    """
484
    pidfile, pid, alive = self._InstancePidAlive(instance_name)
485
    if not alive:
486
      raise errors.HypervisorError("Instance not running, cannot migrate")
487

    
488
    if not live:
489
      self._CallMonitorCommand(instance_name, 'stop')
490

    
491
    migrate_command = ('migrate -d tcp:%s:%s' %
492
                       (target, constants.KVM_MIGRATION_PORT))
493
    self._CallMonitorCommand(instance_name, migrate_command)
494

    
495
    info_command = 'info migrate'
496
    done = False
497
    while not done:
498
      result = self._CallMonitorCommand(instance_name, info_command)
499
      match = self._MIGRATION_STATUS_RE.search(result.stdout)
500
      if not match:
501
        raise errors.HypervisorError("Unknown 'info migrate' result: %s" %
502
                                     result.stdout)
503
      else:
504
        status = match.group(1)
505
        if status == 'completed':
506
          done = True
507
        elif status == 'active':
508
          time.sleep(2)
509
        elif status == 'failed' or status == 'cancelled':
510
          if not live:
511
            self._CallMonitorCommand(instance_name, 'cont')
512
          raise errors.HypervisorError("Migration %s at the kvm level" %
513
                                       status)
514
        else:
515
          logging.info("KVM: unknown migration status '%s'" % status)
516
          time.sleep(2)
517

    
518
    utils.KillProcess(pid)
519
    utils.RemoveFile(pidfile)
520
    utils.RemoveFile(self._InstanceMonitor(instance_name))
521
    utils.RemoveFile(self._InstanceSerial(instance_name))
522
    utils.RemoveFile(self._InstanceKVMRuntime(instance_name))
523

    
524
  def GetNodeInfo(self):
525
    """Return information about the node.
526

527
    @return: a dict with the following keys (values in MiB):
528
          - memory_total: the total memory size on the node
529
          - memory_free: the available memory on the node for instances
530
          - memory_dom0: the memory used by the node itself, if available
531

532
    """
533
    # global ram usage from the xm info command
534
    # memory                 : 3583
535
    # free_memory            : 747
536
    # note: in xen 3, memory has changed to total_memory
537
    try:
538
      fh = file("/proc/meminfo")
539
      try:
540
        data = fh.readlines()
541
      finally:
542
        fh.close()
543
    except EnvironmentError, err:
544
      raise errors.HypervisorError("Failed to list node info: %s" % err)
545

    
546
    result = {}
547
    sum_free = 0
548
    for line in data:
549
      splitfields = line.split(":", 1)
550

    
551
      if len(splitfields) > 1:
552
        key = splitfields[0].strip()
553
        val = splitfields[1].strip()
554
        if key == 'MemTotal':
555
          result['memory_total'] = int(val.split()[0])/1024
556
        elif key in ('MemFree', 'Buffers', 'Cached'):
557
          sum_free += int(val.split()[0])/1024
558
        elif key == 'Active':
559
          result['memory_dom0'] = int(val.split()[0])/1024
560
    result['memory_free'] = sum_free
561

    
562
    cpu_total = 0
563
    try:
564
      fh = open("/proc/cpuinfo")
565
      try:
566
        cpu_total = len(re.findall("(?m)^processor\s*:\s*[0-9]+\s*$",
567
                                   fh.read()))
568
      finally:
569
        fh.close()
570
    except EnvironmentError, err:
571
      raise errors.HypervisorError("Failed to list node info: %s" % err)
572
    result['cpu_total'] = cpu_total
573

    
574
    return result
575

    
576
  @staticmethod
577
  def GetShellCommandForConsole(instance):
578
    """Return a command for connecting to the console of an instance.
579

580
    """
581
    # TODO: we can either try the serial socket or suggest vnc
582
    return "echo Console not available for the kvm hypervisor yet"
583

    
584
  def Verify(self):
585
    """Verify the hypervisor.
586

587
    Check that the binary exists.
588

589
    """
590
    if not os.path.exists(constants.KVM_PATH):
591
      return "The kvm binary ('%s') does not exist." % constants.KVM_PATH
592
    if not os.path.exists(constants.SOCAT_PATH):
593
      return "The socat binary ('%s') does not exist." % constants.SOCAT_PATH
594

    
595

    
596
  @classmethod
597
  def CheckParameterSyntax(cls, hvparams):
598
    """Check the given parameters for validity.
599

600
    For the KVM hypervisor, this only check the existence of the
601
    kernel.
602

603
    @type hvparams:  dict
604
    @param hvparams: dictionary with parameter names/value
605
    @raise errors.HypervisorError: when a parameter is not valid
606

607
    """
608
    super(KVMHypervisor, cls).CheckParameterSyntax(hvparams)
609

    
610
    if not hvparams[constants.HV_KERNEL_PATH]:
611
      raise errors.HypervisorError("Need a kernel for the instance")
612

    
613
    if not os.path.isabs(hvparams[constants.HV_KERNEL_PATH]):
614
      raise errors.HypervisorError("The kernel path must an absolute path")
615

    
616
    if hvparams[constants.HV_INITRD_PATH]:
617
      if not os.path.isabs(hvparams[constants.HV_INITRD_PATH]):
618
        raise errors.HypervisorError("The initrd path must an absolute path"
619
                                     ", if defined")
620

    
621
  def ValidateParameters(self, hvparams):
622
    """Check the given parameters for validity.
623

624
    For the KVM hypervisor, this checks the existence of the
625
    kernel.
626

627
    """
628
    super(KVMHypervisor, self).ValidateParameters(hvparams)
629

    
630
    kernel_path = hvparams[constants.HV_KERNEL_PATH]
631
    if not os.path.isfile(kernel_path):
632
      raise errors.HypervisorError("Instance kernel '%s' not found or"
633
                                   " not a file" % kernel_path)
634
    initrd_path = hvparams[constants.HV_INITRD_PATH]
635
    if initrd_path and not os.path.isfile(initrd_path):
636
      raise errors.HypervisorError("Instance initrd '%s' not found or"
637
                                   " not a file" % initrd_path)