Statistics
| Branch: | Tag: | Revision:

root / lib / hypervisor / hv_xen.py @ e3e66f02

History | View | Annotate | Download (14.1 kB)

1
#
2
#
3

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

24
"""
25

    
26
import os
27
import os.path
28
import time
29
from cStringIO import StringIO
30

    
31
from ganeti import constants
32
from ganeti import errors
33
from ganeti import logger
34
from ganeti import utils
35
from ganeti.hypervisor import hv_base
36

    
37

    
38
class XenHypervisor(hv_base.BaseHypervisor):
39
  """Xen generic hypervisor interface
40

41
  This is the Xen base class used for both Xen PVM and HVM. It contains
42
  all the functionality that is identical for both.
43

44
  """
45

    
46
  @staticmethod
47
  def _WriteConfigFile(instance, block_devices, extra_args):
48
    """Write the Xen config file for the instance.
49

50
    """
51
    raise NotImplementedError
52

    
53
  @staticmethod
54
  def _RemoveConfigFile(instance):
55
    """Remove the xen configuration file.
56

57
    """
58
    utils.RemoveFile("/etc/xen/%s" % instance.name)
59

    
60
  @staticmethod
61
  def _GetXMList(include_node):
62
    """Return the list of running instances.
63

64
    If the `include_node` argument is True, then we return information
65
    for dom0 also, otherwise we filter that from the return value.
66

67
    The return value is a list of (name, id, memory, vcpus, state, time spent)
68

69
    """
70
    for dummy in range(5):
71
      result = utils.RunCmd(["xm", "list"])
72
      if not result.failed:
73
        break
74
      logger.Error("xm list failed (%s): %s" % (result.fail_reason,
75
                                                result.output))
76
      time.sleep(1)
77

    
78
    if result.failed:
79
      raise errors.HypervisorError("xm list failed, retries"
80
                                   " exceeded (%s): %s" %
81
                                   (result.fail_reason, result.stderr))
82

    
83
    # skip over the heading
84
    lines = result.stdout.splitlines()[1:]
85
    result = []
86
    for line in lines:
87
      # The format of lines is:
88
      # Name      ID Mem(MiB) VCPUs State  Time(s)
89
      # Domain-0   0  3418     4 r-----    266.2
90
      data = line.split()
91
      if len(data) != 6:
92
        raise errors.HypervisorError("Can't parse output of xm list,"
93
                                     " line: %s" % line)
94
      try:
95
        data[1] = int(data[1])
96
        data[2] = int(data[2])
97
        data[3] = int(data[3])
98
        data[5] = float(data[5])
99
      except ValueError, err:
100
        raise errors.HypervisorError("Can't parse output of xm list,"
101
                                     " line: %s, error: %s" % (line, err))
102

    
103
      # skip the Domain-0 (optional)
104
      if include_node or data[0] != 'Domain-0':
105
        result.append(data)
106

    
107
    return result
108

    
109
  def ListInstances(self):
110
    """Get the list of running instances.
111

112
    """
113
    xm_list = self._GetXMList(False)
114
    names = [info[0] for info in xm_list]
115
    return names
116

    
117
  def GetInstanceInfo(self, instance_name):
118
    """Get instance properties.
119

120
    Args:
121
      instance_name: the instance name
122

123
    Returns:
124
      (name, id, memory, vcpus, stat, times)
125
    """
126
    xm_list = self._GetXMList(instance_name=="Domain-0")
127
    result = None
128
    for data in xm_list:
129
      if data[0] == instance_name:
130
        result = data
131
        break
132
    return result
133

    
134
  def GetAllInstancesInfo(self):
135
    """Get properties of all instances.
136

137
    Returns:
138
      [(name, id, memory, vcpus, stat, times),...]
139
    """
140
    xm_list = self._GetXMList(False)
141
    return xm_list
142

    
143
  def StartInstance(self, instance, block_devices, extra_args):
144
    """Start an instance."""
145
    self._WriteConfigFile(instance, block_devices, extra_args)
146
    result = utils.RunCmd(["xm", "create", instance.name])
147

    
148
    if result.failed:
149
      raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %
150
                                   (instance.name, result.fail_reason,
151
                                    result.output))
152

    
153
  def StopInstance(self, instance, force=False):
154
    """Stop an instance."""
155
    self._RemoveConfigFile(instance)
156
    if force:
157
      command = ["xm", "destroy", instance.name]
158
    else:
159
      command = ["xm", "shutdown", instance.name]
160
    result = utils.RunCmd(command)
161

    
162
    if result.failed:
163
      raise errors.HypervisorError("Failed to stop instance %s: %s" %
164
                                   (instance.name, result.fail_reason))
165

    
166
  def RebootInstance(self, instance):
167
    """Reboot an instance."""
168
    result = utils.RunCmd(["xm", "reboot", instance.name])
169

    
170
    if result.failed:
171
      raise errors.HypervisorError("Failed to reboot instance %s: %s" %
172
                                   (instance.name, result.fail_reason))
173

    
174
  def GetNodeInfo(self):
175
    """Return information about the node.
176

177
    The return value is a dict, which has to have the following items:
178
      (all values in MiB)
179
      - memory_total: the total memory size on the node
180
      - memory_free: the available memory on the node for instances
181
      - memory_dom0: the memory used by the node itself, if available
182

183
    """
184
    # note: in xen 3, memory has changed to total_memory
185
    result = utils.RunCmd(["xm", "info"])
186
    if result.failed:
187
      logger.Error("Can't run 'xm info': %s" % result.fail_reason)
188
      return None
189

    
190
    xmoutput = result.stdout.splitlines()
191
    result = {}
192
    for line in xmoutput:
193
      splitfields = line.split(":", 1)
194

    
195
      if len(splitfields) > 1:
196
        key = splitfields[0].strip()
197
        val = splitfields[1].strip()
198
        if key == 'memory' or key == 'total_memory':
199
          result['memory_total'] = int(val)
200
        elif key == 'free_memory':
201
          result['memory_free'] = int(val)
202
        elif key == 'nr_cpus':
203
          result['cpu_total'] = int(val)
204
    dom0_info = self.GetInstanceInfo("Domain-0")
205
    if dom0_info is not None:
206
      result['memory_dom0'] = dom0_info[2]
207

    
208
    return result
209

    
210
  @staticmethod
211
  def GetShellCommandForConsole(instance):
212
    """Return a command for connecting to the console of an instance.
213

214
    """
215
    raise NotImplementedError
216

    
217
  def Verify(self):
218
    """Verify the hypervisor.
219

220
    For Xen, this verifies that the xend process is running.
221

222
    """
223
    result = utils.RunCmd(["xm", "info"])
224
    if result.failed:
225
      return "'xm info' failed: %s" % result.fail_reason
226

    
227
  @staticmethod
228
  def _GetConfigFileDiskData(disk_template, block_devices):
229
    """Get disk directive for xen config file.
230

231
    This method builds the xen config disk directive according to the
232
    given disk_template and block_devices.
233

234
    Args:
235
      disk_template: String containing instance disk template
236
      block_devices: List[tuple1,tuple2,...]
237
        tuple: (cfdev, rldev)
238
          cfdev: dict containing ganeti config disk part
239
          rldev: ganeti.bdev.BlockDev object
240

241
    Returns:
242
      String containing disk directive for xen instance config file
243

244
    """
245
    FILE_DRIVER_MAP = {
246
      constants.FD_LOOP: "file",
247
      constants.FD_BLKTAP: "tap:aio",
248
      }
249
    disk_data = []
250
    for cfdev, rldev in block_devices:
251
      if cfdev.dev_type == constants.LD_FILE:
252
        line = "'%s:%s,%s,w'" % (FILE_DRIVER_MAP[cfdev.physical_id[0]],
253
                                 rldev.dev_path, cfdev.iv_name)
254
      else:
255
        line = "'phy:%s,%s,w'" % (rldev.dev_path, cfdev.iv_name)
256
      disk_data.append(line)
257

    
258
    return disk_data
259

    
260

    
261
class XenPvmHypervisor(XenHypervisor):
262
  """Xen PVM hypervisor interface"""
263

    
264
  @classmethod
265
  def _WriteConfigFile(cls, instance, block_devices, extra_args):
266
    """Write the Xen config file for the instance.
267

268
    """
269
    config = StringIO()
270
    config.write("# this is autogenerated by Ganeti, please do not edit\n#\n")
271

    
272
    # kernel handling
273
    if instance.kernel_path in (None, constants.VALUE_DEFAULT):
274
      kpath = constants.XEN_KERNEL
275
    else:
276
      if not os.path.exists(instance.kernel_path):
277
        raise errors.HypervisorError("The kernel %s for instance %s is"
278
                                     " missing" % (instance.kernel_path,
279
                                                   instance.name))
280
      kpath = instance.kernel_path
281
    config.write("kernel = '%s'\n" % kpath)
282

    
283
    # initrd handling
284
    if instance.initrd_path in (None, constants.VALUE_DEFAULT):
285
      if os.path.exists(constants.XEN_INITRD):
286
        initrd_path = constants.XEN_INITRD
287
      else:
288
        initrd_path = None
289
    elif instance.initrd_path == constants.VALUE_NONE:
290
      initrd_path = None
291
    else:
292
      if not os.path.exists(instance.initrd_path):
293
        raise errors.HypervisorError("The initrd %s for instance %s is"
294
                                     " missing" % (instance.initrd_path,
295
                                                   instance.name))
296
      initrd_path = instance.initrd_path
297

    
298
    if initrd_path:
299
      config.write("ramdisk = '%s'\n" % initrd_path)
300

    
301
    # rest of the settings
302
    config.write("memory = %d\n" % instance.memory)
303
    config.write("vcpus = %d\n" % instance.vcpus)
304
    config.write("name = '%s'\n" % instance.name)
305

    
306
    vif_data = []
307
    for nic in instance.nics:
308
      nic_str = "mac=%s, bridge=%s" % (nic.mac, nic.bridge)
309
      ip = getattr(nic, "ip", None)
310
      if ip is not None:
311
        nic_str += ", ip=%s" % ip
312
      vif_data.append("'%s'" % nic_str)
313

    
314
    config.write("vif = [%s]\n" % ",".join(vif_data))
315
    config.write("disk = [%s]\n" % ",".join(
316
                 cls._GetConfigFileDiskData(instance.disk_template,
317
                                            block_devices)))
318
    config.write("root = '/dev/sda ro'\n")
319
    config.write("on_poweroff = 'destroy'\n")
320
    config.write("on_reboot = 'restart'\n")
321
    config.write("on_crash = 'restart'\n")
322
    if extra_args:
323
      config.write("extra = '%s'\n" % extra_args)
324
    # just in case it exists
325
    utils.RemoveFile("/etc/xen/auto/%s" % instance.name)
326
    try:
327
      f = open("/etc/xen/%s" % instance.name, "w")
328
      try:
329
        f.write(config.getvalue())
330
      finally:
331
        f.close()
332
    except IOError, err:
333
      raise errors.OpExecError("Cannot write Xen instance confile"
334
                               " file /etc/xen/%s: %s" % (instance.name, err))
335
    return True
336

    
337
  @staticmethod
338
  def GetShellCommandForConsole(instance):
339
    """Return a command for connecting to the console of an instance.
340

341
    """
342
    return "xm console %s" % instance.name
343

    
344

    
345
class XenHvmHypervisor(XenHypervisor):
346
  """Xen HVM hypervisor interface"""
347

    
348
  @classmethod
349
  def _WriteConfigFile(cls, instance, block_devices, extra_args):
350
    """Create a Xen 3.1 HVM config file.
351

352
    """
353
    config = StringIO()
354
    config.write("# this is autogenerated by Ganeti, please do not edit\n#\n")
355
    config.write("kernel = '/usr/lib/xen/boot/hvmloader'\n")
356
    config.write("builder = 'hvm'\n")
357
    config.write("memory = %d\n" % instance.memory)
358
    config.write("vcpus = %d\n" % instance.vcpus)
359
    config.write("name = '%s'\n" % instance.name)
360
    config.write("pae = 1\n")
361
    config.write("acpi = 1\n")
362
    config.write("apic = 1\n")
363
    arch = os.uname()[4]
364
    if '64' in arch:
365
      config.write("device_model = '/usr/lib64/xen/bin/qemu-dm'\n")
366
    else:
367
      config.write("device_model = '/usr/lib/xen/bin/qemu-dm'\n")
368
    if instance.hvm_boot_order is None:
369
      config.write("boot = '%s'\n" % constants.HT_HVM_DEFAULT_BOOT_ORDER)
370
    else:
371
      config.write("boot = '%s'\n" % instance.hvm_boot_order)
372
    config.write("sdl = 0\n")
373
    config.write("usb = 1\n");
374
    config.write("usbdevice = 'tablet'\n");
375
    config.write("vnc = 1\n")
376
    config.write("vnclisten = '0.0.0.0'\n")
377

    
378
    if instance.network_port > constants.HT_HVM_VNC_BASE_PORT:
379
      display = instance.network_port - constants.HT_HVM_VNC_BASE_PORT
380
      config.write("vncdisplay = %s\n" % display)
381
      config.write("vncunused = 0\n")
382
    else:
383
      config.write("# vncdisplay = 1\n")
384
      config.write("vncunused = 1\n")
385

    
386
    try:
387
      password_file = open(constants.VNC_PASSWORD_FILE, "r")
388
      try:
389
        password = password_file.readline()
390
      finally:
391
        password_file.close()
392
    except IOError:
393
      raise errors.OpExecError("failed to open VNC password file %s " %
394
                               constants.VNC_PASSWORD_FILE)
395

    
396
    config.write("vncpasswd = '%s'\n" % password.rstrip())
397

    
398
    config.write("serial = 'pty'\n")
399
    config.write("localtime = 1\n")
400

    
401
    vif_data = []
402
    for nic in instance.nics:
403
      nic_str = "mac=%s, bridge=%s, type=ioemu" % (nic.mac, nic.bridge)
404
      ip = getattr(nic, "ip", None)
405
      if ip is not None:
406
        nic_str += ", ip=%s" % ip
407
      vif_data.append("'%s'" % nic_str)
408

    
409
    config.write("vif = [%s]\n" % ",".join(vif_data))
410
    iso = "'file:/srv/ganeti/iso/hvm-install.iso,hdc:cdrom,r'"
411
    config.write("disk = [%s, %s]\n" % (",".join(
412
                 cls._GetConfigFileDiskData(instance.disk_template,
413
                                            block_devices)), iso))
414
    config.write("on_poweroff = 'destroy'\n")
415
    config.write("on_reboot = 'restart'\n")
416
    config.write("on_crash = 'restart'\n")
417
    if extra_args:
418
      config.write("extra = '%s'\n" % extra_args)
419
    # just in case it exists
420
    utils.RemoveFile("/etc/xen/auto/%s" % instance.name)
421
    try:
422
      f = open("/etc/xen/%s" % instance.name, "w")
423
      try:
424
        f.write(config.getvalue())
425
      finally:
426
        f.close()
427
    except IOError, err:
428
      raise errors.OpExecError("Cannot write Xen instance confile"
429
                               " file /etc/xen/%s: %s" % (instance.name, err))
430
    return True
431

    
432
  @staticmethod
433
  def GetShellCommandForConsole(instance):
434
    """Return a command for connecting to the console of an instance.
435

436
    """
437
    if instance.network_port is None:
438
      raise errors.OpExecError("no console port defined for %s"
439
                               % instance.name)
440
    else:
441
      raise errors.OpExecError("no PTY console, connect to %s:%s via VNC"
442
                               % (instance.primary_node,
443
                                  instance.network_port))