#
#
-# Copyright (C) 2010 Google Inc.
+# Copyright (C) 2010, 2013 Google Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
TODO:
- move hardcoded parameters into hypervisor parameters, once we
have the container-parameter support
- - implement memory limits, but only optionally, depending on host
- kernel support
Problems/issues:
- LXC is very temperamental; in daemon mode, it succeeds or fails
return utils.ParseCpuMask(cpus)
- def ListInstances(self):
+ @classmethod
+ def _GetCgroupMemoryLimit(cls, instance_name):
+ """Return the memory limit for an instance
+
+ """
+ cgroup = cls._GetCgroupMountPoint()
+ try:
+ memory = int(utils.ReadFile(utils.PathJoin(cgroup, 'lxc',
+ instance_name,
+ "memory.limit_in_bytes")))
+ except EnvironmentError:
+ # memory resource controller may be disabled, ignore
+ memory = 0
+
+ return memory
+
+ def ListInstances(self, hvparams=None):
"""Get the list of running instances.
"""
- return [ iinfo[0] for iinfo in self.GetAllInstancesInfo() ]
+ return [iinfo[0] for iinfo in self.GetAllInstancesInfo()]
- def GetInstanceInfo(self, instance_name):
+ def GetInstanceInfo(self, instance_name, hvparams=None):
"""Get instance properties.
@type instance_name: string
@param instance_name: the instance name
-
+ @type hvparams: dict of strings
+ @param hvparams: hvparams to be used with this instance
+ @rtype: tuple of strings
@return: (name, id, memory, vcpus, stat, times)
"""
return None
cpu_list = self._GetCgroupCpuList(instance_name)
- return (instance_name, 0, 0, len(cpu_list), 0, 0)
+ memory = self._GetCgroupMemoryLimit(instance_name) / (1024 ** 2)
+ return (instance_name, 0, memory, len(cpu_list), 0, 0)
- def GetAllInstancesInfo(self):
+ def GetAllInstancesInfo(self, hvparams=None):
"""Get properties of all instances.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameter
@return: [(name, id, memory, vcpus, stat, times),...]
"""
out.append("lxc.cgroup.cpuset.cpus = %s" %
instance.hvparams[constants.HV_CPU_MASK])
+ # Memory
+ # Conditionally enable, memory resource controller might be disabled
+ cgroup = self._GetCgroupMountPoint()
+ if os.path.exists(utils.PathJoin(cgroup, 'memory.limit_in_bytes')):
+ out.append("lxc.cgroup.memory.limit_in_bytes = %dM" %
+ instance.beparams[constants.BE_MAXMEM])
+
+ if os.path.exists(utils.PathJoin(cgroup, 'memory.memsw.limit_in_bytes')):
+ out.append("lxc.cgroup.memory.memsw.limit_in_bytes = %dM" %
+ instance.beparams[constants.BE_MAXMEM])
+
# Device control
# deny direct device access
out.append("lxc.cgroup.devices.deny = a")
result.output)
if not os.path.ismount(root_dir):
- return
+ return
for mpath in self._GetMountSubdirs(root_dir):
result = utils.RunCmd(["umount", mpath])
# Currently lxc instances don't have memory limits
pass
- def GetNodeInfo(self):
+ def GetNodeInfo(self, hvparams=None):
"""Return information about the node.
- This is just a wrapper over the base GetLinuxNodeInfo method.
-
- @return: a dict with the following keys (values in MiB):
- - memory_total: the total memory size on the node
- - memory_free: the available memory on the node for instances
- - memory_dom0: the memory used by the node itself, if available
+ See L{BaseHypervisor.GetLinuxNodeInfo}.
"""
return self.GetLinuxNodeInfo()
@classmethod
- def GetInstanceConsole(cls, instance, hvparams, beparams):
+ def GetInstanceConsole(cls, instance, primary_node, hvparams, beparams):
"""Return a command for connecting to the console of an instance.
"""
return objects.InstanceConsole(instance=instance.name,
kind=constants.CONS_SSH,
- host=instance.primary_node,
+ host=primary_node.name,
user=constants.SSH_CONSOLE_USER,
command=["lxc-console", "-n", instance.name])
- def Verify(self):
+ def Verify(self, hvparams=None):
"""Verify the hypervisor.
For the LXC manager, it just checks the existence of the base dir.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor parameters to be verified against; not used here
+
@return: Problem description if something is wrong, C{None} otherwise
"""
- if os.path.exists(self._ROOT_DIR):
- return None
- else:
- return "The required directory '%s' does not exist" % self._ROOT_DIR
+ msgs = []
+
+ if not os.path.exists(self._ROOT_DIR):
+ msgs.append("The required directory '%s' does not exist" %
+ self._ROOT_DIR)
+
+ try:
+ self._GetCgroupMountPoint()
+ except errors.HypervisorError, err:
+ msgs.append(str(err))
+
+ return self._FormatVerifyResults(msgs)
@classmethod
- def PowercycleNode(cls):
+ def PowercycleNode(cls, hvparams=None):
"""LXC powercycle, just a wrapper over Linux powercycle.
+ @type hvparams: dict of strings
+ @param hvparams: hypervisor params to be used on this node
+
"""
cls.LinuxPowercycle()
- def MigrateInstance(self, instance, target, live):
+ def MigrateInstance(self, cluster_name, instance, target, live):
"""Migrate an instance.
+ @type cluster_name: string
+ @param cluster_name: name of the cluster
@type instance: L{objects.Instance}
@param instance: the instance to be migrated
@type target: string