Statistics
| Branch: | Tag: | Revision:

root / lib / hypervisor / hv_xen.py @ 0625d08f

History | View | Annotate | Download (28.5 kB)

1
#
2
#
3

    
4
# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 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
"""Xen hypervisors
23

24
"""
25

    
26
import logging
27
from cStringIO import StringIO
28

    
29
from ganeti import constants
30
from ganeti import errors
31
from ganeti import utils
32
from ganeti.hypervisor import hv_base
33
from ganeti import netutils
34
from ganeti import objects
35

    
36

    
37
XEND_CONFIG_FILE = "/etc/xen/xend-config.sxp"
38
XL_CONFIG_FILE = "/etc/xen/xl.conf"
39
VIF_BRIDGE_SCRIPT = "/etc/xen/scripts/vif-bridge"
40
_DOM0_NAME = "Domain-0"
41

    
42

    
43
class XenHypervisor(hv_base.BaseHypervisor):
44
  """Xen generic hypervisor interface
45

46
  This is the Xen base class used for both Xen PVM and HVM. It contains
47
  all the functionality that is identical for both.
48

49
  """
50
  CAN_MIGRATE = True
51
  REBOOT_RETRY_COUNT = 60
52
  REBOOT_RETRY_INTERVAL = 10
53

    
54
  ANCILLARY_FILES = [
55
    XEND_CONFIG_FILE,
56
    XL_CONFIG_FILE,
57
    VIF_BRIDGE_SCRIPT,
58
    ]
59
  ANCILLARY_FILES_OPT = [
60
    XL_CONFIG_FILE,
61
    ]
62

    
63
  @staticmethod
64
  def _ConfigFileName(instance_name):
65
    """Get the config file name for an instance.
66

67
    @param instance_name: instance name
68
    @type instance_name: str
69
    @return: fully qualified path to instance config file
70
    @rtype: str
71

72
    """
73
    return "/etc/xen/%s" % instance_name
74

    
75
  @classmethod
76
  def _WriteConfigFile(cls, instance, startup_memory, block_devices):
77
    """Write the Xen config file for the instance.
78

79
    """
80
    raise NotImplementedError
81

    
82
  @staticmethod
83
  def _WriteConfigFileStatic(instance_name, data):
84
    """Write the Xen config file for the instance.
85

86
    This version of the function just writes the config file from static data.
87

88
    """
89
    # just in case it exists
90
    utils.RemoveFile("/etc/xen/auto/%s" % instance_name)
91
    cfg_file = XenHypervisor._ConfigFileName(instance_name)
92
    try:
93
      utils.WriteFile(cfg_file, data=data)
94
    except EnvironmentError, err:
95
      raise errors.HypervisorError("Cannot write Xen instance configuration"
96
                                   " file %s: %s" % (cfg_file, err))
97

    
98
  @staticmethod
99
  def _ReadConfigFile(instance_name):
100
    """Returns the contents of the instance config file.
101

102
    """
103
    try:
104
      file_content = utils.ReadFile(
105
                       XenHypervisor._ConfigFileName(instance_name))
106
    except EnvironmentError, err:
107
      raise errors.HypervisorError("Failed to load Xen config file: %s" % err)
108
    return file_content
109

    
110
  @staticmethod
111
  def _RemoveConfigFile(instance_name):
112
    """Remove the xen configuration file.
113

114
    """
115
    utils.RemoveFile(XenHypervisor._ConfigFileName(instance_name))
116

    
117
  @classmethod
118
  def _CreateConfigCpus(cls, cpu_mask):
119
    """Create a CPU config string that's compatible with Xen's
120
    configuration file.
121

122
    """
123
    # Convert the string CPU mask to a list of list of int's
124
    cpu_list = utils.ParseMultiCpuMask(cpu_mask)
125

    
126
    if len(cpu_list) == 1:
127
      all_cpu_mapping = cpu_list[0]
128
      if all_cpu_mapping == constants.CPU_PINNING_OFF:
129
        # If CPU pinning has 1 entry that's "all", then remove the
130
        # parameter from the config file
131
        return None
132
      else:
133
        # If CPU pinning has one non-all entry, mapping all vCPUS (the entire
134
        # VM) to one physical CPU, using format 'cpu = "C"'
135
        return "cpu = \"%s\"" % ",".join(map(str, all_cpu_mapping))
136
    else:
137
      def _GetCPUMap(vcpu):
138
        if vcpu[0] == constants.CPU_PINNING_ALL_VAL:
139
          cpu_map = constants.CPU_PINNING_ALL_XEN
140
        else:
141
          cpu_map = ",".join(map(str, vcpu))
142
        return "\"%s\"" % cpu_map
143

    
144
      # build the result string in format 'cpus = [ "c", "c", "c" ]',
145
      # where each c is a physical CPU number, a range, a list, or any
146
      # combination
147
      return "cpus = [ %s ]" % ", ".join(map(_GetCPUMap, cpu_list))
148

    
149
  @staticmethod
150
  def _RunXmList(xmlist_errors):
151
    """Helper function for L{_GetXMList} to run "xm list".
152

153
    """
154
    result = utils.RunCmd([constants.XEN_CMD, "list"])
155
    if result.failed:
156
      logging.error("xm list failed (%s): %s", result.fail_reason,
157
                    result.output)
158
      xmlist_errors.append(result)
159
      raise utils.RetryAgain()
160

    
161
    # skip over the heading
162
    return result.stdout.splitlines()[1:]
163

    
164
  @classmethod
165
  def _GetXMList(cls, include_node):
166
    """Return the list of running instances.
167

168
    If the include_node argument is True, then we return information
169
    for dom0 also, otherwise we filter that from the return value.
170

171
    @return: list of (name, id, memory, vcpus, state, time spent)
172

173
    """
174
    xmlist_errors = []
175
    try:
176
      lines = utils.Retry(cls._RunXmList, 1, 5, args=(xmlist_errors, ))
177
    except utils.RetryTimeout:
178
      if xmlist_errors:
179
        xmlist_result = xmlist_errors.pop()
180

    
181
        errmsg = ("xm list failed, timeout exceeded (%s): %s" %
182
                  (xmlist_result.fail_reason, xmlist_result.output))
183
      else:
184
        errmsg = "xm list failed"
185

    
186
      raise errors.HypervisorError(errmsg)
187

    
188
    result = []
189
    for line in lines:
190
      # The format of lines is:
191
      # Name      ID Mem(MiB) VCPUs State  Time(s)
192
      # Domain-0   0  3418     4 r-----    266.2
193
      data = line.split()
194
      if len(data) != 6:
195
        raise errors.HypervisorError("Can't parse output of xm list,"
196
                                     " line: %s" % line)
197
      try:
198
        data[1] = int(data[1])
199
        data[2] = int(data[2])
200
        data[3] = int(data[3])
201
        data[5] = float(data[5])
202
      except (TypeError, ValueError), err:
203
        raise errors.HypervisorError("Can't parse output of xm list,"
204
                                     " line: %s, error: %s" % (line, err))
205

    
206
      # skip the Domain-0 (optional)
207
      if include_node or data[0] != _DOM0_NAME:
208
        result.append(data)
209

    
210
    return result
211

    
212
  def ListInstances(self):
213
    """Get the list of running instances.
214

215
    """
216
    xm_list = self._GetXMList(False)
217
    names = [info[0] for info in xm_list]
218
    return names
219

    
220
  def GetInstanceInfo(self, instance_name):
221
    """Get instance properties.
222

223
    @param instance_name: the instance name
224

225
    @return: tuple (name, id, memory, vcpus, stat, times)
226

227
    """
228
    xm_list = self._GetXMList(instance_name == _DOM0_NAME)
229
    result = None
230
    for data in xm_list:
231
      if data[0] == instance_name:
232
        result = data
233
        break
234
    return result
235

    
236
  def GetAllInstancesInfo(self):
237
    """Get properties of all instances.
238

239
    @return: list of tuples (name, id, memory, vcpus, stat, times)
240

241
    """
242
    xm_list = self._GetXMList(False)
243
    return xm_list
244

    
245
  def StartInstance(self, instance, block_devices, startup_paused):
246
    """Start an instance.
247

248
    """
249
    startup_memory = self._InstanceStartupMemory(instance)
250
    self._WriteConfigFile(instance, startup_memory, block_devices)
251
    cmd = [constants.XEN_CMD, "create"]
252
    if startup_paused:
253
      cmd.extend(["-p"])
254
    cmd.extend([self._ConfigFileName(instance.name)])
255
    result = utils.RunCmd(cmd)
256

    
257
    if result.failed:
258
      raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
259
                                   (instance.name, result.fail_reason,
260
                                    result.output))
261

    
262
  def StopInstance(self, instance, force=False, retry=False, name=None):
263
    """Stop an instance.
264

265
    """
266
    if name is None:
267
      name = instance.name
268
    self._RemoveConfigFile(name)
269
    if force:
270
      command = [constants.XEN_CMD, "destroy", name]
271
    else:
272
      command = [constants.XEN_CMD, "shutdown", name]
273
    result = utils.RunCmd(command)
274

    
275
    if result.failed:
276
      raise errors.HypervisorError("Failed to stop instance %s: %s, %s" %
277
                                   (name, result.fail_reason, result.output))
278

    
279
  def RebootInstance(self, instance):
280
    """Reboot an instance.
281

282
    """
283
    ini_info = self.GetInstanceInfo(instance.name)
284

    
285
    if ini_info is None:
286
      raise errors.HypervisorError("Failed to reboot instance %s,"
287
                                   " not running" % instance.name)
288

    
289
    result = utils.RunCmd([constants.XEN_CMD, "reboot", instance.name])
290
    if result.failed:
291
      raise errors.HypervisorError("Failed to reboot instance %s: %s, %s" %
292
                                   (instance.name, result.fail_reason,
293
                                    result.output))
294

    
295
    def _CheckInstance():
296
      new_info = self.GetInstanceInfo(instance.name)
297

    
298
      # check if the domain ID has changed or the run time has decreased
299
      if (new_info is not None and
300
          (new_info[1] != ini_info[1] or new_info[5] < ini_info[5])):
301
        return
302

    
303
      raise utils.RetryAgain()
304

    
305
    try:
306
      utils.Retry(_CheckInstance, self.REBOOT_RETRY_INTERVAL,
307
                  self.REBOOT_RETRY_INTERVAL * self.REBOOT_RETRY_COUNT)
308
    except utils.RetryTimeout:
309
      raise errors.HypervisorError("Failed to reboot instance %s: instance"
310
                                   " did not reboot in the expected interval" %
311
                                   (instance.name, ))
312

    
313
  def BalloonInstanceMemory(self, instance, mem):
314
    """Balloon an instance memory to a certain value.
315

316
    @type instance: L{objects.Instance}
317
    @param instance: instance to be accepted
318
    @type mem: int
319
    @param mem: actual memory size to use for instance runtime
320

321
    """
322
    cmd = [constants.XEN_CMD, "mem-set", instance.name, mem]
323
    result = utils.RunCmd(cmd)
324
    if result.failed:
325
      raise errors.HypervisorError("Failed to balloon instance %s: %s (%s)" %
326
                                   (instance.name, result.fail_reason,
327
                                    result.output))
328
    cmd = ["sed", "-ie", "s/^memory.*$/memory = %s/" % mem]
329
    cmd.append(XenHypervisor._ConfigFileName(instance.name))
330
    result = utils.RunCmd(cmd)
331
    if result.failed:
332
      raise errors.HypervisorError("Failed to update memory for %s: %s (%s)" %
333
                                   (instance.name, result.fail_reason,
334
                                    result.output))
335

    
336
  def GetNodeInfo(self):
337
    """Return information about the node.
338

339
    @return: a dict with the following keys (memory values in MiB):
340
          - memory_total: the total memory size on the node
341
          - memory_free: the available memory on the node for instances
342
          - memory_dom0: the memory used by the node itself, if available
343
          - nr_cpus: total number of CPUs
344
          - nr_nodes: in a NUMA system, the number of domains
345
          - nr_sockets: the number of physical CPU sockets in the node
346
          - hv_version: the hypervisor version in the form (major, minor)
347

348
    """
349
    result = utils.RunCmd([constants.XEN_CMD, "info"])
350
    if result.failed:
351
      logging.error("Can't run 'xm info' (%s): %s", result.fail_reason,
352
                    result.output)
353
      return None
354

    
355
    xmoutput = result.stdout.splitlines()
356
    result = {}
357
    cores_per_socket = threads_per_core = nr_cpus = None
358
    xen_major, xen_minor = None, None
359
    memory_total = None
360
    memory_free = None
361

    
362
    for line in xmoutput:
363
      splitfields = line.split(":", 1)
364

    
365
      if len(splitfields) > 1:
366
        key = splitfields[0].strip()
367
        val = splitfields[1].strip()
368

    
369
        # note: in xen 3, memory has changed to total_memory
370
        if key == "memory" or key == "total_memory":
371
          memory_total = int(val)
372
        elif key == "free_memory":
373
          memory_free = int(val)
374
        elif key == "nr_cpus":
375
          nr_cpus = result["cpu_total"] = int(val)
376
        elif key == "nr_nodes":
377
          result["cpu_nodes"] = int(val)
378
        elif key == "cores_per_socket":
379
          cores_per_socket = int(val)
380
        elif key == "threads_per_core":
381
          threads_per_core = int(val)
382
        elif key == "xen_major":
383
          xen_major = int(val)
384
        elif key == "xen_minor":
385
          xen_minor = int(val)
386

    
387
    if None not in [cores_per_socket, threads_per_core, nr_cpus]:
388
      result["cpu_sockets"] = nr_cpus / (cores_per_socket * threads_per_core)
389

    
390
    total_instmem = 0
391
    for (name, _, mem, vcpus, _, _) in self._GetXMList(True):
392
      if name == _DOM0_NAME:
393
        result["memory_dom0"] = mem
394
        result["dom0_cpus"] = vcpus
395

    
396
      # Include Dom0 in total memory usage
397
      total_instmem += mem
398

    
399
    if memory_free is not None:
400
      result["memory_free"] = memory_free
401

    
402
    if memory_total is not None:
403
      result["memory_total"] = memory_total
404

    
405
    # Calculate memory used by hypervisor
406
    if None not in [memory_total, memory_free, total_instmem]:
407
      result["memory_hv"] = memory_total - memory_free - total_instmem
408

    
409
    if not (xen_major is None or xen_minor is None):
410
      result[constants.HV_NODEINFO_KEY_VERSION] = (xen_major, xen_minor)
411

    
412
    return result
413

    
414
  @classmethod
415
  def GetInstanceConsole(cls, instance, hvparams, beparams):
416
    """Return a command for connecting to the console of an instance.
417

418
    """
419
    return objects.InstanceConsole(instance=instance.name,
420
                                   kind=constants.CONS_SSH,
421
                                   host=instance.primary_node,
422
                                   user=constants.GANETI_RUNAS,
423
                                   command=[constants.XM_CONSOLE_WRAPPER,
424
                                            instance.name])
425

    
426
  def Verify(self):
427
    """Verify the hypervisor.
428

429
    For Xen, this verifies that the xend process is running.
430

431
    """
432
    result = utils.RunCmd([constants.XEN_CMD, "info"])
433
    if result.failed:
434
      return "'xm info' failed: %s, %s" % (result.fail_reason, result.output)
435

    
436
  @staticmethod
437
  def _GetConfigFileDiskData(block_devices, blockdev_prefix):
438
    """Get disk directive for xen config file.
439

440
    This method builds the xen config disk directive according to the
441
    given disk_template and block_devices.
442

443
    @param block_devices: list of tuples (cfdev, rldev):
444
        - cfdev: dict containing ganeti config disk part
445
        - rldev: ganeti.bdev.BlockDev object
446
    @param blockdev_prefix: a string containing blockdevice prefix,
447
                            e.g. "sd" for /dev/sda
448

449
    @return: string containing disk directive for xen instance config file
450

451
    """
452
    FILE_DRIVER_MAP = {
453
      constants.FD_LOOP: "file",
454
      constants.FD_BLKTAP: "tap:aio",
455
      }
456
    disk_data = []
457
    if len(block_devices) > 24:
458
      # 'z' - 'a' = 24
459
      raise errors.HypervisorError("Too many disks")
460
    namespace = [blockdev_prefix + chr(i + ord("a")) for i in range(24)]
461
    for sd_name, (cfdev, dev_path) in zip(namespace, block_devices):
462
      if cfdev.mode == constants.DISK_RDWR:
463
        mode = "w"
464
      else:
465
        mode = "r"
466
      if cfdev.dev_type == constants.LD_FILE:
467
        line = "'%s:%s,%s,%s'" % (FILE_DRIVER_MAP[cfdev.physical_id[0]],
468
                                  dev_path, sd_name, mode)
469
      else:
470
        line = "'phy:%s,%s,%s'" % (dev_path, sd_name, mode)
471
      disk_data.append(line)
472

    
473
    return disk_data
474

    
475
  def MigrationInfo(self, instance):
476
    """Get instance information to perform a migration.
477

478
    @type instance: L{objects.Instance}
479
    @param instance: instance to be migrated
480
    @rtype: string
481
    @return: content of the xen config file
482

483
    """
484
    return self._ReadConfigFile(instance.name)
485

    
486
  def AcceptInstance(self, instance, info, target):
487
    """Prepare to accept an instance.
488

489
    @type instance: L{objects.Instance}
490
    @param instance: instance to be accepted
491
    @type info: string
492
    @param info: content of the xen config file on the source node
493
    @type target: string
494
    @param target: target host (usually ip), on this node
495

496
    """
497
    pass
498

    
499
  def FinalizeMigrationDst(self, instance, info, success):
500
    """Finalize an instance migration.
501

502
    After a successful migration we write the xen config file.
503
    We do nothing on a failure, as we did not change anything at accept time.
504

505
    @type instance: L{objects.Instance}
506
    @param instance: instance whose migration is being finalized
507
    @type info: string
508
    @param info: content of the xen config file on the source node
509
    @type success: boolean
510
    @param success: whether the migration was a success or a failure
511

512
    """
513
    if success:
514
      self._WriteConfigFileStatic(instance.name, info)
515

    
516
  def MigrateInstance(self, instance, target, live):
517
    """Migrate an instance to a target node.
518

519
    The migration will not be attempted if the instance is not
520
    currently running.
521

522
    @type instance: L{objects.Instance}
523
    @param instance: the instance to be migrated
524
    @type target: string
525
    @param target: ip address of the target node
526
    @type live: boolean
527
    @param live: perform a live migration
528

529
    """
530
    if self.GetInstanceInfo(instance.name) is None:
531
      raise errors.HypervisorError("Instance not running, cannot migrate")
532

    
533
    port = instance.hvparams[constants.HV_MIGRATION_PORT]
534

    
535
    if not netutils.TcpPing(target, port, live_port_needed=True):
536
      raise errors.HypervisorError("Remote host %s not listening on port"
537
                                   " %s, cannot migrate" % (target, port))
538

    
539
    # FIXME: migrate must be upgraded for transitioning to "xl" (xen 4.1).
540
    #        This should be reworked in Ganeti 2.7
541
    #  ssh must recognize the key of the target host for the migration
542
    args = [constants.XEN_CMD, "migrate"]
543
    if constants.XEN_CMD == constants.XEN_CMD_XM:
544
      args.extend(["-p", "%d" % port])
545
      if live:
546
        args.append("-l")
547
    elif constants.XEN_CMD == constants.XEN_CMD_XL:
548
      args.extend(["-C", self._ConfigFileName(instance.name)])
549
    else:
550
      raise errors.HypervisorError("Unsupported xen command: %s" %
551
                                   constants.XEN_CMD)
552

    
553
    args.extend([instance.name, target])
554
    result = utils.RunCmd(args)
555
    if result.failed:
556
      raise errors.HypervisorError("Failed to migrate instance %s: %s" %
557
                                   (instance.name, result.output))
558

    
559
  def FinalizeMigrationSource(self, instance, success, live):
560
    """Finalize the instance migration on the source node.
561

562
    @type instance: L{objects.Instance}
563
    @param instance: the instance that was migrated
564
    @type success: bool
565
    @param success: whether the migration succeeded or not
566
    @type live: bool
567
    @param live: whether the user requested a live migration or not
568

569
    """
570
    # pylint: disable=W0613
571
    if success:
572
      # remove old xen file after migration succeeded
573
      try:
574
        self._RemoveConfigFile(instance.name)
575
      except EnvironmentError:
576
        logging.exception("Failure while removing instance config file")
577

    
578
  def GetMigrationStatus(self, instance):
579
    """Get the migration status
580

581
    As MigrateInstance for Xen is still blocking, if this method is called it
582
    means that MigrateInstance has completed successfully. So we can safely
583
    assume that the migration was successful and notify this fact to the client.
584

585
    @type instance: L{objects.Instance}
586
    @param instance: the instance that is being migrated
587
    @rtype: L{objects.MigrationStatus}
588
    @return: the status of the current migration (one of
589
             L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
590
             progress info that can be retrieved from the hypervisor
591

592
    """
593
    return objects.MigrationStatus(status=constants.HV_MIGRATION_COMPLETED)
594

    
595
  @classmethod
596
  def PowercycleNode(cls):
597
    """Xen-specific powercycle.
598

599
    This first does a Linux reboot (which triggers automatically a Xen
600
    reboot), and if that fails it tries to do a Xen reboot. The reason
601
    we don't try a Xen reboot first is that the xen reboot launches an
602
    external command which connects to the Xen hypervisor, and that
603
    won't work in case the root filesystem is broken and/or the xend
604
    daemon is not working.
605

606
    """
607
    try:
608
      cls.LinuxPowercycle()
609
    finally:
610
      utils.RunCmd([constants.XEN_CMD, "debug", "R"])
611

    
612

    
613
class XenPvmHypervisor(XenHypervisor):
614
  """Xen PVM hypervisor interface"""
615

    
616
  PARAMETERS = {
617
    constants.HV_USE_BOOTLOADER: hv_base.NO_CHECK,
618
    constants.HV_BOOTLOADER_PATH: hv_base.OPT_FILE_CHECK,
619
    constants.HV_BOOTLOADER_ARGS: hv_base.NO_CHECK,
620
    constants.HV_KERNEL_PATH: hv_base.REQ_FILE_CHECK,
621
    constants.HV_INITRD_PATH: hv_base.OPT_FILE_CHECK,
622
    constants.HV_ROOT_PATH: hv_base.NO_CHECK,
623
    constants.HV_KERNEL_ARGS: hv_base.NO_CHECK,
624
    constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK,
625
    constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,
626
    # TODO: Add a check for the blockdev prefix (matching [a-z:] or similar).
627
    constants.HV_BLOCKDEV_PREFIX: hv_base.NO_CHECK,
628
    constants.HV_REBOOT_BEHAVIOR:
629
      hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),
630
    constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_CHECK,
631
    }
632

    
633
  @classmethod
634
  def _WriteConfigFile(cls, instance, startup_memory, block_devices):
635
    """Write the Xen config file for the instance.
636

637
    """
638
    hvp = instance.hvparams
639
    config = StringIO()
640
    config.write("# this is autogenerated by Ganeti, please do not edit\n#\n")
641

    
642
    # if bootloader is True, use bootloader instead of kernel and ramdisk
643
    # parameters.
644
    if hvp[constants.HV_USE_BOOTLOADER]:
645
      # bootloader handling
646
      bootloader_path = hvp[constants.HV_BOOTLOADER_PATH]
647
      if bootloader_path:
648
        config.write("bootloader = '%s'\n" % bootloader_path)
649
      else:
650
        raise errors.HypervisorError("Bootloader enabled, but missing"
651
                                     " bootloader path")
652

    
653
      bootloader_args = hvp[constants.HV_BOOTLOADER_ARGS]
654
      if bootloader_args:
655
        config.write("bootargs = '%s'\n" % bootloader_args)
656
    else:
657
      # kernel handling
658
      kpath = hvp[constants.HV_KERNEL_PATH]
659
      config.write("kernel = '%s'\n" % kpath)
660

    
661
      # initrd handling
662
      initrd_path = hvp[constants.HV_INITRD_PATH]
663
      if initrd_path:
664
        config.write("ramdisk = '%s'\n" % initrd_path)
665

    
666
    # rest of the settings
667
    config.write("memory = %d\n" % startup_memory)
668
    config.write("maxmem = %d\n" % instance.beparams[constants.BE_MAXMEM])
669
    config.write("vcpus = %d\n" % instance.beparams[constants.BE_VCPUS])
670
    cpu_pinning = cls._CreateConfigCpus(hvp[constants.HV_CPU_MASK])
671
    if cpu_pinning:
672
      config.write("%s\n" % cpu_pinning)
673

    
674
    config.write("name = '%s'\n" % instance.name)
675

    
676
    vif_data = []
677
    for nic in instance.nics:
678
      nic_str = "mac=%s" % (nic.mac)
679
      ip = getattr(nic, "ip", None)
680
      if ip is not None:
681
        nic_str += ", ip=%s" % ip
682
      if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
683
        nic_str += ", bridge=%s" % nic.nicparams[constants.NIC_LINK]
684
      vif_data.append("'%s'" % nic_str)
685

    
686
    disk_data = cls._GetConfigFileDiskData(block_devices,
687
                                           hvp[constants.HV_BLOCKDEV_PREFIX])
688

    
689
    config.write("vif = [%s]\n" % ",".join(vif_data))
690
    config.write("disk = [%s]\n" % ",".join(disk_data))
691

    
692
    if hvp[constants.HV_ROOT_PATH]:
693
      config.write("root = '%s'\n" % hvp[constants.HV_ROOT_PATH])
694
    config.write("on_poweroff = 'destroy'\n")
695
    if hvp[constants.HV_REBOOT_BEHAVIOR] == constants.INSTANCE_REBOOT_ALLOWED:
696
      config.write("on_reboot = 'restart'\n")
697
    else:
698
      config.write("on_reboot = 'destroy'\n")
699
    config.write("on_crash = 'restart'\n")
700
    config.write("extra = '%s'\n" % hvp[constants.HV_KERNEL_ARGS])
701
    cls._WriteConfigFileStatic(instance.name, config.getvalue())
702

    
703
    return True
704

    
705

    
706
class XenHvmHypervisor(XenHypervisor):
707
  """Xen HVM hypervisor interface"""
708

    
709
  ANCILLARY_FILES = XenHypervisor.ANCILLARY_FILES + [
710
    constants.VNC_PASSWORD_FILE,
711
    ]
712
  ANCILLARY_FILES_OPT = XenHypervisor.ANCILLARY_FILES_OPT + [
713
    constants.VNC_PASSWORD_FILE,
714
    ]
715

    
716
  PARAMETERS = {
717
    constants.HV_ACPI: hv_base.NO_CHECK,
718
    constants.HV_BOOT_ORDER: (True, ) +
719
      (lambda x: x and len(x.strip("acdn")) == 0,
720
       "Invalid boot order specified, must be one or more of [acdn]",
721
       None, None),
722
    constants.HV_CDROM_IMAGE_PATH: hv_base.OPT_FILE_CHECK,
723
    constants.HV_DISK_TYPE:
724
      hv_base.ParamInSet(True, constants.HT_HVM_VALID_DISK_TYPES),
725
    constants.HV_NIC_TYPE:
726
      hv_base.ParamInSet(True, constants.HT_HVM_VALID_NIC_TYPES),
727
    constants.HV_PAE: hv_base.NO_CHECK,
728
    constants.HV_VNC_BIND_ADDRESS:
729
      (False, netutils.IP4Address.IsValid,
730
       "VNC bind address is not a valid IP address", None, None),
731
    constants.HV_KERNEL_PATH: hv_base.REQ_FILE_CHECK,
732
    constants.HV_DEVICE_MODEL: hv_base.REQ_FILE_CHECK,
733
    constants.HV_VNC_PASSWORD_FILE: hv_base.REQ_FILE_CHECK,
734
    constants.HV_MIGRATION_PORT: hv_base.REQ_NET_PORT_CHECK,
735
    constants.HV_MIGRATION_MODE: hv_base.MIGRATION_MODE_CHECK,
736
    constants.HV_USE_LOCALTIME: hv_base.NO_CHECK,
737
    # TODO: Add a check for the blockdev prefix (matching [a-z:] or similar).
738
    constants.HV_BLOCKDEV_PREFIX: hv_base.NO_CHECK,
739
    constants.HV_REBOOT_BEHAVIOR:
740
      hv_base.ParamInSet(True, constants.REBOOT_BEHAVIORS),
741
    constants.HV_CPU_MASK: hv_base.OPT_MULTI_CPU_MASK_CHECK,
742
    }
743

    
744
  @classmethod
745
  def _WriteConfigFile(cls, instance, startup_memory, block_devices):
746
    """Create a Xen 3.1 HVM config file.
747

748
    """
749
    hvp = instance.hvparams
750

    
751
    config = StringIO()
752
    config.write("# this is autogenerated by Ganeti, please do not edit\n#\n")
753

    
754
    # kernel handling
755
    kpath = hvp[constants.HV_KERNEL_PATH]
756
    config.write("kernel = '%s'\n" % kpath)
757

    
758
    config.write("builder = 'hvm'\n")
759
    config.write("memory = %d\n" % startup_memory)
760
    config.write("maxmem = %d\n" % instance.beparams[constants.BE_MAXMEM])
761
    config.write("vcpus = %d\n" % instance.beparams[constants.BE_VCPUS])
762
    cpu_pinning = cls._CreateConfigCpus(hvp[constants.HV_CPU_MASK])
763
    if cpu_pinning:
764
      config.write("%s\n" % cpu_pinning)
765

    
766
    config.write("name = '%s'\n" % instance.name)
767
    if hvp[constants.HV_PAE]:
768
      config.write("pae = 1\n")
769
    else:
770
      config.write("pae = 0\n")
771
    if hvp[constants.HV_ACPI]:
772
      config.write("acpi = 1\n")
773
    else:
774
      config.write("acpi = 0\n")
775
    config.write("apic = 1\n")
776
    config.write("device_model = '%s'\n" % hvp[constants.HV_DEVICE_MODEL])
777
    config.write("boot = '%s'\n" % hvp[constants.HV_BOOT_ORDER])
778
    config.write("sdl = 0\n")
779
    config.write("usb = 1\n")
780
    config.write("usbdevice = 'tablet'\n")
781
    config.write("vnc = 1\n")
782
    if hvp[constants.HV_VNC_BIND_ADDRESS] is None:
783
      config.write("vnclisten = '%s'\n" % constants.VNC_DEFAULT_BIND_ADDRESS)
784
    else:
785
      config.write("vnclisten = '%s'\n" % hvp[constants.HV_VNC_BIND_ADDRESS])
786

    
787
    if instance.network_port > constants.VNC_BASE_PORT:
788
      display = instance.network_port - constants.VNC_BASE_PORT
789
      config.write("vncdisplay = %s\n" % display)
790
      config.write("vncunused = 0\n")
791
    else:
792
      config.write("# vncdisplay = 1\n")
793
      config.write("vncunused = 1\n")
794

    
795
    vnc_pwd_file = hvp[constants.HV_VNC_PASSWORD_FILE]
796
    try:
797
      password = utils.ReadFile(vnc_pwd_file)
798
    except EnvironmentError, err:
799
      raise errors.HypervisorError("Failed to open VNC password file %s: %s" %
800
                                   (vnc_pwd_file, err))
801

    
802
    config.write("vncpasswd = '%s'\n" % password.rstrip())
803

    
804
    config.write("serial = 'pty'\n")
805
    if hvp[constants.HV_USE_LOCALTIME]:
806
      config.write("localtime = 1\n")
807

    
808
    vif_data = []
809
    nic_type = hvp[constants.HV_NIC_TYPE]
810
    if nic_type is None:
811
      # ensure old instances don't change
812
      nic_type_str = ", type=ioemu"
813
    elif nic_type == constants.HT_NIC_PARAVIRTUAL:
814
      nic_type_str = ", type=paravirtualized"
815
    else:
816
      nic_type_str = ", model=%s, type=ioemu" % nic_type
817
    for nic in instance.nics:
818
      nic_str = "mac=%s%s" % (nic.mac, nic_type_str)
819
      ip = getattr(nic, "ip", None)
820
      if ip is not None:
821
        nic_str += ", ip=%s" % ip
822
      if nic.nicparams[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:
823
        nic_str += ", bridge=%s" % nic.nicparams[constants.NIC_LINK]
824
      vif_data.append("'%s'" % nic_str)
825

    
826
    config.write("vif = [%s]\n" % ",".join(vif_data))
827

    
828
    disk_data = cls._GetConfigFileDiskData(block_devices,
829
                                           hvp[constants.HV_BLOCKDEV_PREFIX])
830

    
831
    iso_path = hvp[constants.HV_CDROM_IMAGE_PATH]
832
    if iso_path:
833
      iso = "'file:%s,hdc:cdrom,r'" % iso_path
834
      disk_data.append(iso)
835

    
836
    config.write("disk = [%s]\n" % (",".join(disk_data)))
837

    
838
    config.write("on_poweroff = 'destroy'\n")
839
    if hvp[constants.HV_REBOOT_BEHAVIOR] == constants.INSTANCE_REBOOT_ALLOWED:
840
      config.write("on_reboot = 'restart'\n")
841
    else:
842
      config.write("on_reboot = 'destroy'\n")
843
    config.write("on_crash = 'restart'\n")
844
    cls._WriteConfigFileStatic(instance.name, config.getvalue())
845

    
846
    return True