コード例 #1
0
    def unplug_backend_devices(device_list):
        """Unplug the backend devices"""
        for dev in device_list:
            try:
                dev.unplug_hook()
                drive = dev.get_param("drive")
                if drive:
                    if Flags.BLOCKDEV in vm.devices.caps:
                        format_node = vm.devices[drive]
                        nodes = [format_node]
                        nodes.extend((n for n in format_node.get_child_nodes()))
                        for node in nodes:
                            if not node.verify_unplug(
                                    node.unplug(vm.monitor), vm.monitor):
                                raise DeviceUnplugError(
                                    node, "Failed to unplug blockdev node.",
                                    vm.devices)
                            vm.devices.remove(node, True if isinstance(
                                node, qdevices.QBlockdevFormatNode) else False)
                            if not isinstance(node,
                                              qdevices.QBlockdevFormatNode):
                                format_node.del_child_node(node)
                    else:
                        vm.devices.remove(drive)
                vm.devices.remove(dev, True)

            except (DeviceError, KeyError) as exc:
                dev.unplug_unhook()
                raise DeviceUnplugError(dev, exc, vm.devices)
コード例 #2
0
    def _unplug_atomic(self, device, monitor):
        """ Function unplug device to devices representation. """
        device = self.vm.devices[device]
        with _LOCK:
            self.vm.devices.set_dirty()

        out = self._plug(device.unplug, monitor)
        if not utils_misc.wait_for(
                lambda: device.verify_unplug(out, monitor) is True,
                first=1,
                step=5,
                timeout=self.VERIFY_UNPLUG_TIMEOUT):
            with _LOCK:
                self.vm.devices.set_clean()
            return out, device.verify_unplug(out, monitor)
        ver_out = device.verify_unplug(out, monitor)

        try:
            device.unplug_hook()
            drive = device.get_param("drive")
            if drive:
                if self.vm.check_capability(Flags.BLOCKDEV):
                    # top node
                    node = self.vm.devices[drive]
                    nodes = [node]

                    # Build the full nodes list
                    for node in nodes:
                        child_nodes = node.get_child_nodes()
                        nodes.extend(child_nodes)

                    for node in nodes:
                        parent_node = node.get_parent_node()
                        child_nodes = node.get_child_nodes()
                        recursive = True if len(child_nodes) > 0 else False
                        if not node.verify_unplug(
                                self._plug(node.unplug, monitor), monitor):
                            raise DeviceUnplugError(
                                node, "Failed to unplug blockdev node.", self)
                        with _LOCK:
                            self.vm.devices.remove(node, recursive)
                        if parent_node:
                            parent_node.del_child_node(node)
                else:
                    with _LOCK:
                        self.vm.devices.remove(drive)

            with _LOCK:
                self.vm.devices.remove(device, True)
            if ver_out is True:
                with _LOCK:
                    self.vm.devices.set_clean()
            elif out is False:
                raise DeviceUnplugError(
                    device, "Device wasn't unplugged in qemu, but it was "
                    "unplugged in device representation.", self)
        except (DeviceError, KeyError) as exc:
            device.unplug_unhook()
            raise DeviceUnplugError(device, exc, self)
        return out, ver_out
コード例 #3
0
    def _unplug_atomic(self, device, monitor):
        """ Function unplug device to devices representation. """
        device = self.vm.devices[device]
        with _LOCK:
            self.vm.devices.set_dirty()

        out = device.unplug(monitor)
        if not utils_misc.wait_for(
                lambda: device.verify_unplug(out, monitor) is True,
                first=1,
                step=5,
                timeout=60):
            with _LOCK:
                self.vm.devices.set_clean()
            return out, device.verify_unplug(out, monitor)
        ver_out = device.verify_unplug(out, monitor)

        try:
            device.unplug_hook()
            drive = device.get_param("drive")
            if drive:
                if self.vm.check_capability(Flags.BLOCKDEV):
                    format_node = self.vm.devices[drive]
                    nodes = [format_node]
                    nodes.extend((n for n in format_node.get_child_nodes()))
                    for node in nodes:
                        if not node.verify_unplug(node.unplug(monitor),
                                                  monitor):
                            raise DeviceUnplugError(
                                node, "Failed to unplug blockdev node.", self)
                        with _LOCK:
                            self.vm.devices.remove(
                                node, True if isinstance(
                                    node, qdevices.QBlockdevFormatNode) else
                                False)
                        if not isinstance(node, qdevices.QBlockdevFormatNode):
                            format_node.del_child_node(node)
                else:
                    with _LOCK:
                        self.vm.devices.remove(drive)

            with _LOCK:
                self.vm.devices.remove(device, True)
            if ver_out is True:
                with _LOCK:
                    self.vm.devices.set_clean()
            elif out is False:
                raise DeviceUnplugError(
                    device, "Device wasn't unplugged in qemu, but it was "
                    "unplugged in device representation.", self)
        except (DeviceError, KeyError) as exc:
            device.unplug_unhook()
            raise DeviceUnplugError(device, exc, self)
        return out, ver_out