Coverage for drivers/qcow2util.py: 26%

715 raise xs_errors.XenError("Multiple openers for {}".format(path)) # TODO: There might be multiple PID? Yes, we can have the chain enabled for multiple leaf (i.e. after a clone), taken into account in cleanup.py

716 pid = pid_openers[0]

717 tapdiskList = TapCtl.list(pid=pid)

718 if len(tapdiskList) > 1: #TODO: There might more than one minor for this blktap?

719 raise xs_errors.XenError("TapdiskAlreadyRunning", "There is multiple minor for this tapdisk process")

720 minor = tapdiskList[0]["minor"]

721 return (pid, minor)

722 raise xs_errors.XenError("TapdiskFailed", "No tapdisk process found for {}".format(path))

723

724 @override

725 def coalesceOnline(self, path: str) -> int:

726 pid, minor = self._getTapdisk(path)

727 logger = util.LoggerCounter(10)

728

729 try:

730 TapCtl.commit(pid, minor, QCOW2_TYPE, path)

731 # We need to wait for query to return concluded

732 # We are technically ininterruptible since being interrupted will only stop checking if the job is done.

733 # We need to call `tap-ctl cancel` if we are interrupted, it is done in cleanup.py code.

734

735 status, nb, _ = TapCtl.query(pid, minor)

736 if status == "undefined":

737 util.SMlog("Tapdisk {} (m: {}) coalesce status undefined for {}".format(pid, minor, path))

738 return 0

739

740 while status != "concluded":

741 time.sleep(1)

742 status, nb, _ = TapCtl.query(pid, minor, quiet=True)

743 logger.log("Got status {} for tapdisk {} (m: {})".format(status, pid, minor))

744 return nb

745 except TapCtl.CommandFailure:

746 util.SMlog("Query command failed on tapdisk instance {}. Raising...".format(pid))

747 raise

748

749 @override

750 def cancelCoalesceOnline(self, path: str) -> None:

751 pid, minor = self._getTapdisk(path)

752

753 try:

754 TapCtl.cancel_commit(pid, minor)

755 except TapCtl.CommandFailure:

756 util.SMlog("Cancel command failed on tapdisk instance {}. Raising...".format(pid))

757 raise

758

759 @override

760 def coalesce(self, path: str) -> int:

761 # -d on commit make it not empty the original image since we don't intend to keep it

762 cmd = [QEMU_IMG, "commit", "-f", QCOW2_TYPE, path, "-d"]

763 ret = cast(str, self._ioretry(cmd)) # Allows to parse for byte coalesced, our qemu-img is supposed to be patched to output it.

764 lines = ret.splitlines()

765 if re.match("Image committed.", lines[-1]):

766 res_line = lines[-2]

767 else:

768 res_line = lines[-1]

769

770 results = re.match(r"\((\d+)/(\d+)\)", res_line)

771 if results:

772 committed_bytes = int(results.group(1))

773 return committed_bytes

774 raise xs_errors.XenError("TapdiskFailed", "Couldn't get commited size from qemu-img commit call") # TODO: We might not want to raise in this case, it would break if the qemu-img called isn't modified to print the coalesce result even if it succeeded in coalesceing

775

776 @override

777 def create(self, path: str, size: int, static: bool, msize: int = 0, block_size: Optional[int] = None) -> None:

778 cmd = [QEMU_IMG, "create", "-f", QCOW2_TYPE, path, str(size)]

779 if static:

780 cmd.extend(["-o", "preallocation=full"])

781 if block_size:

782 cmd.extend(["-o", f"cluster_size={str(block_size)}"])

783 self._ioretry(cmd)

784 self.setHidden(path, False) #We add hidden header at creation

785

786 @override

787 def snapshot(

788 self,

789 path: str,

790 parent: str,

791 parentRaw: bool,

792 msize: int = 0,

793 checkEmpty: bool = True

794 ) -> None:

795 if parentRaw:

796 parent_type = RAW_TYPE

797 parent_cluster_size = QCOW2_DEFAULT_CLUSTER_SIZE

798 else:

799 parent_type = QCOW2_TYPE

800 parent_cluster_size = self.getBlockSize(parent)

801

802 cmd = [QEMU_IMG, "create", "-f", QCOW2_TYPE, "-b", parent, "-F", parent_type, "-o", f"cluster_size={parent_cluster_size}", path]

803 self._ioretry(cmd)

804 self.setHidden(path, False) #We add hidden header at creation

805

806 @override

807 def canSnapshotRaw(self, size: int) -> bool:

808 return True

809

810 @override

811 def check(

812 self,

813 path: str,

814 ignoreMissingFooter: bool = False,

815 fast: bool = False

816 ) -> CowUtil.CheckResult:

817 cmd = [QEMU_IMG, "check", path]

818 try:

819 self._ioretry(cmd)

820 return CowUtil.CheckResult.Success

821 except util.CommandException as e:

822 if e.code in (errno.EROFS, errno.EMEDIUMTYPE):

823 return CowUtil.CheckResult.Unavailable

824 # 1/EPERM is error in internal during check

825 # 2/ENOENT is QCOW corrupted

826 # 3/ESRCH is QCow has leaked clusters

827 # 63/ENOSR is check unavailable on this image type

828 return CowUtil.CheckResult.Fail

829

830 @override

831 def revert(self, path: str, jFile: str) -> None:

832 pass #Used to get back from a failed operation using a journal, NOOP for qcow2

833

834 @override

835 def repair(self, path: str) -> None:

836 cmd = [QEMU_IMG, "check", "-f", QCOW2_TYPE, "-r", "all", path]

837 self._ioretry(cmd)

838

839 @override

840 def validateAndRoundImageSize(self, size: int) -> int:

841 if size < 0 or size > MAX_QCOW_SIZE:

842 raise xs_errors.XenError(

843 "VDISize",

844 opterr="VDI size must be between {} MB and {} MB".format(MIN_QCOW_SIZE // (1024*1024), MAX_QCOW_SIZE // (1024 * 1024))

845 )

846

847 return util.roundup(QCOW2_DEFAULT_CLUSTER_SIZE, size)

848

849 @override

850 def getKeyHash(self, path: str) -> Optional[str]:

851 pass

852

853 @override

854 def setKey(self, path: str, key_hash: str) -> None:

855 pass

856

857 @override

858 def isCoalesceableOnRemote(self) -> bool:

859 return True

Coverage for drivers/qcow2util.py : 26%

471 statements

Coverage for drivers/qcow2util.py : 26%

471 statements 150 run 321 missing 0 excluded 2 partial

471 statements