import logging
from ganeti import constants
-from ganeti import errors # pylint: disable-msg=W0611
+from ganeti import errors # pylint: disable=W0611
from ganeti import utils
+from ganeti import objects
from ganeti.hypervisor import hv_base
from ganeti.errors import HypervisorError
"""
_ROOT_DIR = constants.RUN_GANETI_DIR + "/lxc"
- _LOG_FILE = constants.LOG_DIR + "hv_lxc.log"
_DEVS = [
"c 1:3", # /dev/null
"c 1:5", # /dev/zero
_DIR_MODE = 0755
PARAMETERS = {
+ constants.HV_CPU_MASK: hv_base.OPT_CPU_MASK_CHECK,
}
def __init__(self):
def _GetMountSubdirs(path):
"""Return the list of mountpoints under a given path.
- This function is Linux-specific.
-
"""
- #TODO(iustin): investigate and document non-linux options
- #(e.g. via mount output)
- data = []
- fh = open("/proc/mounts", "r")
- try:
- for line in fh:
- _, mountpoint, _ = line.split(" ", 2)
- if (mountpoint.startswith(path) and
- mountpoint != path):
- data.append(mountpoint)
- finally:
- fh.close()
- data.sort(key=lambda x: x.count("/"), reverse=True)
- return data
+ result = []
+ for _, mountpoint, _, _ in utils.GetMounts():
+ if (mountpoint.startswith(path) and
+ mountpoint != path):
+ result.append(mountpoint)
+
+ result.sort(key=lambda x: x.count("/"), reverse=True)
+ return result
@classmethod
def _InstanceDir(cls, instance_name):
"""
return utils.PathJoin(cls._ROOT_DIR, instance_name + ".conf")
+ @classmethod
+ def _InstanceLogFile(cls, instance_name):
+ """Return the log file for an instance.
+
+ """
+ return utils.PathJoin(cls._ROOT_DIR, instance_name + ".log")
+
+ @classmethod
+ def _GetCgroupMountPoint(cls):
+ for _, mountpoint, fstype, _ in utils.GetMounts():
+ if fstype == "cgroup":
+ return mountpoint
+ raise errors.HypervisorError("The cgroup filesystem is not mounted")
+
+ @classmethod
+ def _GetCgroupCpuList(cls, instance_name):
+ """Return the list of CPU ids for an instance.
+
+ """
+ cgroup = cls._GetCgroupMountPoint()
+ try:
+ cpus = utils.ReadFile(utils.PathJoin(cgroup,
+ instance_name,
+ "cpuset.cpus"))
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Getting CPU list for instance"
+ " %s failed: %s" % (instance_name, err))
+
+ return utils.ParseCpuMask(cpus)
+
def ListInstances(self):
"""Get the list of running instances.
"""
result = utils.RunCmd(["lxc-ls"])
if result.failed:
- raise errors.HypervisorError("Can't run lxc-ls: %s" % result.output)
+ raise errors.HypervisorError("Running lxc-ls failed: %s" % result.output)
return result.stdout.splitlines()
def GetInstanceInfo(self, instance_name):
"""
# TODO: read container info from the cgroup mountpoint
- return (instance_name, 0, 0, 0, 0, 0)
+
+ result = utils.RunCmd(["lxc-info", "-n", instance_name])
+ if result.failed:
+ raise errors.HypervisorError("Running lxc-info failed: %s" %
+ result.output)
+ # lxc-info output examples:
+ # 'ganeti-lxc-test1' is STOPPED
+ # 'ganeti-lxc-test1' is RUNNING
+ _, state = result.stdout.rsplit(None, 1)
+ if state != "RUNNING":
+ return None
+
+ cpu_list = self._GetCgroupCpuList(instance_name)
+ return (instance_name, 0, 0, len(cpu_list), 0, 0)
def GetAllInstancesInfo(self):
"""Get properties of all instances.
@return: [(name, id, memory, vcpus, stat, times),...]
"""
- # TODO: read container info from the cgroup mountpoint
data = []
for name in self.ListInstances():
- data.append((name, 0, 0, 0, 0, 0))
+ data.append(self.GetInstanceInfo(name))
return data
def _CreateConfigFile(self, instance, root_dir):
- """Create an lxc.conf file for an instance"""
+ """Create an lxc.conf file for an instance.
+
+ """
out = []
# hostname
out.append("lxc.utsname = %s" % instance.name)
# separate pseudo-TTY instances
out.append("lxc.pts = 255")
- # standard TTYs/console
+ # standard TTYs
out.append("lxc.tty = 6")
+ # console log file
+ console_log = utils.PathJoin(self._ROOT_DIR, instance.name + ".console")
+ try:
+ utils.WriteFile(console_log, data="", mode=constants.SECURE_FILE_MODE)
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Creating console log file %s for"
+ " instance %s failed: %s" %
+ (console_log, instance.name, err))
+ out.append("lxc.console = %s" % console_log)
# root FS
out.append("lxc.rootfs = %s" % root_dir)
# TODO: additional mounts, if we disable CAP_SYS_ADMIN
+ # CPUs
+ if instance.hvparams[constants.HV_CPU_MASK]:
+ cpu_list = utils.ParseCpuMask(instance.hvparams[constants.HV_CPU_MASK])
+ cpus_in_mask = len(cpu_list)
+ if cpus_in_mask != instance.beparams["vcpus"]:
+ raise errors.HypervisorError("Number of VCPUs (%d) doesn't match"
+ " the number of CPUs in the"
+ " cpu_mask (%d)" %
+ (instance.beparams["vcpus"],
+ cpus_in_mask))
+ out.append("lxc.cgroup.cpuset.cpus = %s" %
+ instance.hvparams[constants.HV_CPU_MASK])
+
# Device control
# deny direct device access
out.append("lxc.cgroup.devices.deny = a")
return "\n".join(out) + "\n"
- def StartInstance(self, instance, block_devices):
+ def StartInstance(self, instance, block_devices, startup_paused):
"""Start an instance.
- For LCX, we try to mount the block device and execute 'lxc-start
- start' (we use volatile containers).
+ For LCX, we try to mount the block device and execute 'lxc-start'.
+ We use volatile containers.
"""
root_dir = self._InstanceDir(instance.name)
try:
utils.EnsureDirs([(root_dir, self._DIR_MODE)])
except errors.GenericError, err:
- raise HypervisorError("Cannot create instance directory: %s", str(err))
+ raise HypervisorError("Creating instance directory failed: %s", str(err))
conf_file = self._InstanceConfFile(instance.name)
utils.WriteFile(conf_file, data=self._CreateConfigFile(instance, root_dir))
+ log_file = self._InstanceLogFile(instance.name)
+ if not os.path.exists(log_file):
+ try:
+ utils.WriteFile(log_file, data="", mode=constants.SECURE_FILE_MODE)
+ except EnvironmentError, err:
+ raise errors.HypervisorError("Creating hypervisor log file %s for"
+ " instance %s failed: %s" %
+ (log_file, instance.name, err))
+
if not os.path.ismount(root_dir):
if not block_devices:
raise HypervisorError("LXC needs at least one disk")
sda_dev_path = block_devices[0][1]
result = utils.RunCmd(["mount", sda_dev_path, root_dir])
if result.failed:
- raise HypervisorError("Can't mount the chroot dir: %s" % result.output)
- # TODO: replace the global log file with a per-instance log file
+ raise HypervisorError("Mounting the root dir of LXC instance %s"
+ " failed: %s" % (instance.name, result.output))
result = utils.RunCmd(["lxc-start", "-n", instance.name,
- "-o", self._LOG_FILE, "-l", "DEBUG",
+ "-o", log_file,
+ "-l", "DEBUG",
"-f", conf_file, "-d"])
if result.failed:
raise HypervisorError("Running the lxc-start script failed: %s" %
if not retry and not force:
result = utils.RunCmd(["chroot", root_dir, "poweroff"])
if result.failed:
- raise HypervisorError("Can't run 'poweroff' for the instance: %s" %
- result.output)
+ raise HypervisorError("Running 'poweroff' on the instance"
+ " failed: %s" % result.output)
time.sleep(2)
result = utils.RunCmd(["lxc-stop", "-n", name])
if result.failed:
msg = ("Processes still alive in the chroot: %s" %
utils.RunCmd("fuser -vm %s" % root_dir).output)
logging.error(msg)
- raise HypervisorError("Can't umount the chroot dir: %s (%s)" %
+ raise HypervisorError("Unmounting the chroot dir failed: %s (%s)" %
(result.output, msg))
def RebootInstance(self, instance):
raise HypervisorError("The LXC hypervisor doesn't implement the"
" reboot functionality")
+ def BalloonInstanceMemory(self, instance, mem):
+ """Balloon an instance memory to a certain value.
+
+ @type instance: L{objects.Instance}
+ @param instance: instance to be accepted
+ @type mem: int
+ @param mem: actual memory size to use for instance runtime
+
+ """
+ # Currently lxc instances don't have memory limits
+ pass
+
def GetNodeInfo(self):
"""Return information about the node.
return self.GetLinuxNodeInfo()
@classmethod
- def GetShellCommandForConsole(cls, instance, hvparams, beparams):
+ def GetInstanceConsole(cls, instance, hvparams, beparams):
"""Return a command for connecting to the console of an instance.
"""
- return "lxc-console -n %s" % instance.name
+ return objects.InstanceConsole(instance=instance.name,
+ kind=constants.CONS_SSH,
+ host=instance.primary_node,
+ user=constants.GANETI_RUNAS,
+ command=["lxc-console", "-n", instance.name])
def Verify(self):
"""Verify the hypervisor.
@param live: whether to do a live or non-live migration
"""
- raise HypervisorError("Migration not supported by the LXC hypervisor")
+ raise HypervisorError("Migration is not supported by the LXC hypervisor")
+
+ def GetMigrationStatus(self, instance):
+ """Get the migration status
+
+ @type instance: L{objects.Instance}
+ @param instance: the instance that is being migrated
+ @rtype: L{objects.MigrationStatus}
+ @return: the status of the current migration (one of
+ L{constants.HV_MIGRATION_VALID_STATUSES}), plus any additional
+ progress info that can be retrieved from the hypervisor
+
+ """
+ raise HypervisorError("Migration is not supported by the LXC hypervisor")
projects / ganeti-local / blobdiff