654 lines
28 KiB
C#
654 lines
28 KiB
C#
// Copyright (C) 2025, The Duplicati Team
|
|
// https://duplicati.com, hello@duplicati.com
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the "Software"),
|
|
// to deal in the Software without restriction, including without limitation
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
// and/or sell copies of the Software, and to permit persons to whom the
|
|
// Software is furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
// DEALINGS IN THE SOFTWARE.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Xml.Linq;
|
|
using Duplicati.Proprietary.DiskImage;
|
|
using NUnit.Framework;
|
|
|
|
#nullable enable
|
|
|
|
namespace Duplicati.UnitTest.DiskImage
|
|
{
|
|
/// <summary>
|
|
/// macOS implementation of <see cref="IDiskImageHelper"/> using hdiutil and standard macOS tools.
|
|
/// </summary>
|
|
internal class MacOSDiskImageHelper : IDiskImageHelper
|
|
{
|
|
/// <inheritdoc />
|
|
public string CreateDisk(string imagePath, long sizeB)
|
|
{
|
|
// Ensure the directory exists
|
|
var directory = Path.GetDirectoryName(imagePath);
|
|
if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
|
|
Directory.CreateDirectory(directory);
|
|
|
|
// Delete existing image if it exists
|
|
if (File.Exists(imagePath))
|
|
try
|
|
{
|
|
CleanupDisk(imagePath);
|
|
}
|
|
catch
|
|
{
|
|
// Ignore errors during cleanup
|
|
}
|
|
|
|
// Create a raw disk image using hdiutil
|
|
// Use UDIF format with "Free Space" filesystem (unformatted)
|
|
RunProcess("hdiutil", $"create -size {sizeB} -type UDIF -layout NONE -o \"{imagePath}\"");
|
|
|
|
var output = RunProcess("hdiutil", $"attach -nomount -noautofsck \"{imagePath}\"");
|
|
|
|
// Parse the disk device from output (e.g., "/dev/disk4")
|
|
var diskDevice = output.Trim().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault()?.Trim()
|
|
?? throw new InvalidOperationException("Failed to get disk device from hdiutil attach output");
|
|
|
|
// Return the raw device path for direct I/O
|
|
return diskDevice.Replace("/dev/disk", "/dev/rdisk");
|
|
}
|
|
|
|
private string[] GetPartitionNames(string diskIdentifier)
|
|
{
|
|
var output = RunProcess("diskutil", $"list {diskIdentifier}");
|
|
|
|
// Very hardcoded to disks with < 10 partitions and no identifiers with spaces. Should be sufficient for test purposes.
|
|
return output
|
|
.Split('\n')
|
|
.Select(x => x.Trim())
|
|
.Where(x => x.Length > 1 && x[1] == ':')
|
|
.Skip(2)
|
|
.Select(x => x.Split([' '], StringSplitOptions.RemoveEmptyEntries).LastOrDefault())
|
|
.Where(x => x is not null)
|
|
.Select(x => x!)
|
|
.ToArray();
|
|
}
|
|
|
|
private string[] GetMountPoints(string diskIdentifier)
|
|
{
|
|
var partitions = GetPartitionNames(diskIdentifier);
|
|
var mountPoints = new System.Collections.Generic.List<string>();
|
|
|
|
foreach (var partition in partitions)
|
|
{
|
|
var output = RunProcess("diskutil", $"info /dev/{partition}");
|
|
var lines = output
|
|
.Split('\n')
|
|
.Select(l => l.Trim())
|
|
.Where(l => l.Length > 0)
|
|
.ToList();
|
|
|
|
// Check if this is an APFS Physical Store
|
|
var isApfsPhysicalStore = output.Contains("APFS Physical Store") ||
|
|
lines.Any(l => l.StartsWith("Partition Type:") && l.Contains("Apple_APFS"));
|
|
|
|
if (isApfsPhysicalStore)
|
|
{
|
|
// For APFS, get the container and then get volumes from it
|
|
var containerLine = lines
|
|
.FirstOrDefault(l => l.StartsWith("APFS Container:"));
|
|
|
|
if (containerLine != null)
|
|
{
|
|
var containerId = containerLine.Split([':'], 2)[1].Trim();
|
|
// Get volumes from the container (they are like disk5s1, disk5s2, etc.)
|
|
var containerVolumes = GetApfsContainerVolumes(containerId);
|
|
foreach (var volume in containerVolumes)
|
|
{
|
|
var volumeOutput = RunProcess("diskutil", $"info {volume}");
|
|
var mountPoint = ExtractMountPoint(volumeOutput);
|
|
if (!string.IsNullOrEmpty(mountPoint))
|
|
mountPoints.Add(mountPoint);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Regular partition - extract mount point directly
|
|
var mountPoint = ExtractMountPoint(output);
|
|
if (!string.IsNullOrEmpty(mountPoint))
|
|
mountPoints.Add(mountPoint);
|
|
}
|
|
}
|
|
|
|
return [.. mountPoints];
|
|
}
|
|
|
|
private string[] GetApfsContainerVolumes(string containerId)
|
|
{
|
|
var output = RunProcess("diskutil", $"list {containerId}");
|
|
|
|
// Parse volumes from container listing (format: disk5s1, disk5s2, etc.)
|
|
return output
|
|
.Split('\n')
|
|
.Select(x => x.Trim())
|
|
.Where(x => x.Contains("APFS Volume", StringComparison.OrdinalIgnoreCase))
|
|
.Select(x => x.Split(' ')[^1])
|
|
.ToArray();
|
|
}
|
|
|
|
private string? ExtractMountPoint(string diskutilInfoOutput)
|
|
{
|
|
// Look for "Mount Point:" line
|
|
var mountLine = diskutilInfoOutput
|
|
.Split('\n')
|
|
.FirstOrDefault(l => l.Trim().StartsWith("Mount Point:"));
|
|
|
|
if (mountLine == null)
|
|
return null;
|
|
|
|
var mountPoint = mountLine.Split([':'], 2)[1].Trim();
|
|
|
|
// Return null if not mounted or not applicable
|
|
if (string.IsNullOrEmpty(mountPoint) ||
|
|
mountPoint == "Not mounted" ||
|
|
mountPoint == "Not applicable (no file system)")
|
|
return null;
|
|
|
|
return mountPoint;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string[] InitializeDisk(string diskIdentifier, Proprietary.DiskImage.PartitionTableType tableType, (Proprietary.DiskImage.FileSystemType, long)[] partitions)
|
|
{
|
|
if (tableType == Proprietary.DiskImage.PartitionTableType.Unknown)
|
|
return []; // No partition table, so nothing to initialize
|
|
|
|
// Use diskutil to partition the disk with the specified scheme
|
|
// "Free Space" means no filesystem, just the partition table
|
|
var partitionStrings = partitions.Length > 0 ? partitions.Select((p, i) =>
|
|
{
|
|
var fsType = p.Item1 switch
|
|
{
|
|
Proprietary.DiskImage.FileSystemType.NTFS => throw new NotSupportedException("NTFS is not natively supported on macOS for creating partitions. Use ExFAT or FAT32 instead."),
|
|
Proprietary.DiskImage.FileSystemType.FAT32 => "\"MS-DOS FAT32\"",
|
|
Proprietary.DiskImage.FileSystemType.ExFAT => "ExFAT",
|
|
Proprietary.DiskImage.FileSystemType.HFSPlus => "HFS+",
|
|
Proprietary.DiskImage.FileSystemType.APFS => "APFS",
|
|
_ => throw new ArgumentException($"Unsupported filesystem type on macOS: {p.Item1}", nameof(partitions))
|
|
};
|
|
|
|
var sizeArg = p.Item2 > 0 ? $"{p.Item2}" : "0";
|
|
return $"{fsType} \"Partition {i + 1}\" {sizeArg}";
|
|
})
|
|
: ["\"Free Space\" \"\" 0"];
|
|
var partitionArgs = string.Join(" ", partitionStrings);
|
|
|
|
RunProcess("diskutil", $"partitionDisk {diskIdentifier} {tableType.ToString().ToUpperInvariant()} {partitionArgs}");
|
|
|
|
if (partitions.Length == 0)
|
|
return [];
|
|
|
|
return GetMountPoints(diskIdentifier);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public string[] Mount(string diskIdentifier, string? baseMountPath = null, bool readOnly = false, FileSystemType[]? fileSystemTypes = null)
|
|
{
|
|
// Check if already mounted
|
|
try
|
|
{
|
|
var existingMountPoints = GetMountPoints(diskIdentifier);
|
|
if (existingMountPoints.Length > 0 && existingMountPoints.All(mp => mp.StartsWith(baseMountPath ?? "/Volumes/")))
|
|
{
|
|
return existingMountPoints;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Ignore errors and try mounting
|
|
}
|
|
|
|
// Get the list of partitions first to ensure we target the correct disk
|
|
var partitions = GetPartitionNames(diskIdentifier);
|
|
|
|
List<string> mountPoints = [];
|
|
foreach (var partition in partitions)
|
|
{
|
|
var output = RunProcess("diskutil", $"info /dev/{partition}");
|
|
|
|
// Check if this is an APFS Physical Store
|
|
var isApfsPhysicalStore = output.Contains("APFS Physical Store") ||
|
|
output.Split('\n').Any(l => l.Trim().StartsWith("Partition Type:") && l.Contains("Apple_APFS"));
|
|
|
|
if (isApfsPhysicalStore)
|
|
{
|
|
// For APFS, get the container and mount volumes from it
|
|
var containerLine = output
|
|
.Split('\n')
|
|
.FirstOrDefault(l => l.Trim().StartsWith("APFS Container:"));
|
|
|
|
if (containerLine != null)
|
|
{
|
|
var containerId = containerLine.Split([':'], 2)[1].Trim();
|
|
// Get volumes from the container (they are like disk5s1, disk5s2, etc.)
|
|
var containerVolumes = GetApfsContainerVolumes(containerId);
|
|
foreach (var volume in containerVolumes)
|
|
{
|
|
MountVolume(volume, baseMountPath, mountPoints, readOnly);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Regular partition - mount directly
|
|
MountVolume(partition, baseMountPath, mountPoints, readOnly);
|
|
}
|
|
}
|
|
|
|
return mountPoints.Count == 0 ? WaitForMountPoints(diskIdentifier) : [.. mountPoints];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Mounts a single volume/partition with optional custom mount point.
|
|
/// </summary>
|
|
/// <param name="volume">The volume identifier (e.g., "disk4s1").</param>
|
|
/// <param name="baseMountPath">Optional base path for mounting.</param>
|
|
/// <param name="mountPoints">List to collect mount points.</param>
|
|
/// <param name="readOnly">Indicates whether the volume should be mounted as read-only.</param>
|
|
private void MountVolume(string volume, string? baseMountPath, List<string> mountPoints, bool readOnly)
|
|
{
|
|
var dir = "";
|
|
var mountArgs = readOnly ? "-readOnly" : "";
|
|
if (baseMountPath is not null)
|
|
{
|
|
dir = Path.Combine(baseMountPath, volume);
|
|
Directory.CreateDirectory(dir); // diskutil will mount to this directory instead of /Volumes/ if it exists, so create it ahead of time
|
|
var readOnlyArg = readOnly ? " -readOnly" : "";
|
|
mountArgs = $"{readOnlyArg} -mountPoint \"{dir}\"";
|
|
}
|
|
|
|
// Unmount first in case it's already mounted somewhere else, to ensure it gets mounted to the correct location
|
|
var oldMp = ExtractMountPoint(RunProcess("diskutil", $"info /dev/{volume}"));
|
|
if (oldMp is not null && !oldMp.StartsWith(baseMountPath ?? "/Volumes/"))
|
|
RunProcess("diskutil", $"unmount force /dev/{volume}");
|
|
|
|
RunProcess("diskutil", $"mount -nobrowse {mountArgs} /dev/{volume}");
|
|
|
|
// Verify the mount
|
|
var mp = RunProcess("diskutil", $"info /dev/{volume}");
|
|
var mountPoint = ExtractMountPoint(mp);
|
|
if (!string.IsNullOrEmpty(mountPoint))
|
|
{
|
|
mountPoints.Add(mountPoint);
|
|
|
|
if (!mountPoint.StartsWith(baseMountPath ?? "/Volumes/"))
|
|
{
|
|
TestContext.Progress.WriteLine($"Warning: Volume /dev/{volume} did not mount to expected location. Output: {mp}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TestContext.Progress.WriteLine($"Warning: Volume /dev/{volume} did not report a mount point after mounting. Output: {mp}");
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Waits for mount points to be fully established after a mount operation.
|
|
/// Uses exponential backoff starting from a short delay to minimize wait time
|
|
/// in the common case while still handling slow mounts.
|
|
///
|
|
/// After mounting (especially after raw partition table writes during restore),
|
|
/// macOS may need time to fully recognize filesystems and establish mount points
|
|
/// in /Volumes/. Without this retry loop, mount points may be:
|
|
/// - Not yet available (empty array)
|
|
/// - In a transient location like /private/var/ instead of /Volumes/
|
|
/// - Mounted but with empty directories (filesystem not yet recognized)
|
|
/// </summary>
|
|
/// <param name="diskIdentifier">The disk identifier to check mount points for.</param>
|
|
/// <returns>An array of mount point paths.</returns>
|
|
private string[] WaitForMountPoints(string diskIdentifier)
|
|
{
|
|
const int maxRetries = 10;
|
|
const int initialDelayMs = 100;
|
|
const int maxDelayMs = 1000;
|
|
|
|
var delayMs = initialDelayMs;
|
|
for (int i = 0; i < maxRetries; i++)
|
|
{
|
|
var mountPoints = GetMountPoints(diskIdentifier);
|
|
|
|
if (mountPoints.Length > 0)
|
|
{
|
|
// Check if any mount points are in a transient location (not under /Volumes/)
|
|
if (mountPoints.Any(mp => !mp.StartsWith("/Volumes/")))
|
|
{
|
|
Thread.Sleep(delayMs);
|
|
delayMs = Math.Min(delayMs * 2, maxDelayMs);
|
|
continue;
|
|
}
|
|
|
|
// Check if all mount points have filesystem entries (not empty)
|
|
var allNonEmpty = mountPoints.All(mp =>
|
|
{
|
|
try { return Directory.GetFileSystemEntries(mp).Length > 0; }
|
|
catch { return false; }
|
|
});
|
|
|
|
if (allNonEmpty || i == maxRetries - 1)
|
|
return mountPoints;
|
|
}
|
|
|
|
Thread.Sleep(delayMs);
|
|
delayMs = Math.Min(delayMs * 2, maxDelayMs);
|
|
}
|
|
|
|
// Final attempt - return whatever we have
|
|
return GetMountPoints(diskIdentifier);
|
|
}
|
|
|
|
public void Unmount(string diskIdentifier)
|
|
{
|
|
int retryCount = 3;
|
|
for (int i = 0; i < retryCount; i++)
|
|
{
|
|
try
|
|
{
|
|
// Unmount all volumes on the disk
|
|
RunProcess("diskutil", $"unmountDisk {diskIdentifier}");
|
|
}
|
|
catch
|
|
{
|
|
// Sometimes an unmount is issued too fast after writing data, which makes diskutil throw an errory.
|
|
Thread.Sleep(500);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void FlushDisk(string diskIdentifier)
|
|
{
|
|
// On macOS, use sync to flush all filesystem buffers
|
|
RunProcess("sync", "");
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void CleanupDisk(string imagePath, string? diskIdentifier = null)
|
|
{
|
|
if (diskIdentifier is null)
|
|
{
|
|
var output = RunProcess("hdiutil", $"info");
|
|
|
|
diskIdentifier = output
|
|
.Split("================================================")
|
|
.Skip(1) // Skip the header
|
|
.Select(d =>
|
|
{
|
|
var lines = d
|
|
.Split('\n')
|
|
.Select(l => l.Trim())
|
|
.Where(l => l.Length > 0)
|
|
.ToList();
|
|
var imagePathLine = lines.FirstOrDefault(l => l.StartsWith("image-path"));
|
|
if (imagePathLine == null)
|
|
return null;
|
|
|
|
var path = imagePathLine.Split([':'], 2)[1].Trim();
|
|
if (!string.Equals(path, imagePath, StringComparison.OrdinalIgnoreCase))
|
|
return null;
|
|
|
|
var deviceLine = lines.FirstOrDefault(l => l.StartsWith("/dev/"));
|
|
if (deviceLine == null)
|
|
return null;
|
|
|
|
var device = deviceLine
|
|
.Split(['\t'], 2)[0]
|
|
.Trim();
|
|
|
|
return device;
|
|
})
|
|
.FirstOrDefault(d => d != null);
|
|
}
|
|
|
|
if (diskIdentifier is null)
|
|
throw new InvalidOperationException($"Failed to determine disk identifier for {imagePath} during cleanup");
|
|
|
|
try
|
|
{
|
|
RunProcess("diskutil", $"eject {diskIdentifier}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TestContext.Progress.WriteLine($"Warning: Failed to detach disk image: {ex.Message}");
|
|
}
|
|
|
|
try
|
|
{
|
|
if (File.Exists(imagePath))
|
|
File.Delete(imagePath);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
TestContext.Progress.WriteLine($"Warning: Failed to delete disk image file: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool HasRequiredPrivileges()
|
|
{
|
|
// Root is not required for virtual disks.
|
|
return true;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Proprietary.DiskImage.PartitionTableGeometry GetPartitionTable(string diskIdentifier)
|
|
{
|
|
var output = RunProcess("diskutil", $"info {diskIdentifier}");
|
|
|
|
var lines = output
|
|
.Split('\n')
|
|
.Select(l => l.Trim())
|
|
.Where(l => l.Length > 0)
|
|
.ToList();
|
|
|
|
PartitionTableType tableType = PartitionTableType.Unknown;
|
|
long size = -1;
|
|
int sectorSize = -1;
|
|
foreach (var line in lines)
|
|
{
|
|
var parts = line.Split([':'], 2);
|
|
switch (parts[0].Trim())
|
|
{
|
|
case "Device Identifier":
|
|
if (!diskIdentifier.EndsWith(parts[1].Trim(), StringComparison.OrdinalIgnoreCase))
|
|
throw new InvalidOperationException($"Disk identifier mismatch in diskutil info output: {diskIdentifier} doesn't end with {parts[1].Trim()}");
|
|
break;
|
|
case "Content (IOContent)":
|
|
tableType = parts[1].Trim() switch
|
|
{
|
|
"GUID_partition_scheme" => PartitionTableType.GPT,
|
|
"FDisk_partition_scheme" => PartitionTableType.MBR,
|
|
_ => PartitionTableType.Unknown
|
|
};
|
|
break;
|
|
case "Disk Size":
|
|
var totalbytesPart = parts[1].Trim().Split(' ').Skip(2).FirstOrDefault()?.TrimStart('(').TrimEnd(')');
|
|
if (totalbytesPart is not null)
|
|
size = long.TryParse(totalbytesPart, out long parsedSize) ? parsedSize : -1;
|
|
break;
|
|
case "Device Block Size":
|
|
var sectorSizePart = parts[1].Trim().Split(' ').FirstOrDefault();
|
|
if (sectorSizePart != null && int.TryParse(sectorSizePart, out int parsedSectorSize))
|
|
sectorSize = parsedSectorSize;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (size == -1 || sectorSize == -1)
|
|
throw new InvalidOperationException($"Failed to retrieve partition table information for disk {diskIdentifier}");
|
|
|
|
return new Proprietary.DiskImage.PartitionTableGeometry
|
|
{
|
|
Type = tableType,
|
|
Size = size,
|
|
SectorSize = sectorSize
|
|
// Ignore the rest for now.
|
|
};
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public PartitionGeometry[] GetPartitions(string diskIdentifier)
|
|
{
|
|
var names = GetPartitionNames(diskIdentifier);
|
|
|
|
var partitions = new List<PartitionGeometry>();
|
|
foreach (var name in names)
|
|
{
|
|
var output = RunProcess("diskutil", $"info /dev/{name}");
|
|
|
|
var lines = output
|
|
.Split('\n')
|
|
.Select(l => l.Trim())
|
|
.Where(l => l.Length > 0)
|
|
.ToList();
|
|
|
|
PartitionGeometry partition = new()
|
|
{
|
|
Number = int.TryParse(name.AsSpan(name.Length - 1), out int num) ? num : -1,
|
|
Type = PartitionType.Unknown,
|
|
StartOffset = -1,
|
|
Size = -1,
|
|
Name = null,
|
|
FilesystemType = Proprietary.DiskImage.FileSystemType.Unknown,
|
|
VolumeGuid = null,
|
|
TableType = PartitionTableType.Unknown
|
|
};
|
|
|
|
foreach (var line in lines)
|
|
{
|
|
var parts = line.Split([':'], 2);
|
|
switch (parts[0].Trim())
|
|
{
|
|
case "Device Node":
|
|
if (!string.Equals(parts[1].Trim(), $"/dev/{name}", StringComparison.OrdinalIgnoreCase))
|
|
throw new InvalidOperationException($"Partition identifier mismatch in diskutil info output: expected /dev/{name}, got {parts[1].Trim()}");
|
|
break;
|
|
case "Partition Offset":
|
|
var offsetPart = parts[1].Trim().Split(' ').FirstOrDefault();
|
|
if (offsetPart != null && long.TryParse(offsetPart, out long parsedOffset))
|
|
partition.StartOffset = parsedOffset;
|
|
break;
|
|
case "Disk Size":
|
|
var sizePart = parts[1].Trim().Split(' ').FirstOrDefault();
|
|
if (sizePart != null && long.TryParse(sizePart, out long parsedSize))
|
|
partition.Size = parsedSize;
|
|
break;
|
|
case "Volume Name":
|
|
partition.Name = parts[1].Trim();
|
|
break;
|
|
case "File System Personality":
|
|
partition.FilesystemType = parts[1].Trim() switch
|
|
{
|
|
"MS-DOS FAT32" => Proprietary.DiskImage.FileSystemType.FAT32,
|
|
"ExFAT" => Proprietary.DiskImage.FileSystemType.ExFAT,
|
|
"HFS+" => Proprietary.DiskImage.FileSystemType.HFSPlus,
|
|
"APFS" => Proprietary.DiskImage.FileSystemType.APFS,
|
|
_ => Proprietary.DiskImage.FileSystemType.Unknown
|
|
};
|
|
break;
|
|
case "Volume UUID":
|
|
if (Guid.TryParse(parts[1].Trim(), out Guid parsedGuid))
|
|
partition.VolumeGuid = parsedGuid;
|
|
break;
|
|
default:
|
|
// Ignore other lines for now
|
|
break;
|
|
}
|
|
}
|
|
|
|
partitions.Add(partition);
|
|
}
|
|
|
|
return partitions.ToArray();
|
|
}
|
|
|
|
public string ReAttach(string imagePath, string diskIdentifier, PartitionTableType tableType, bool readOnly = false)
|
|
{
|
|
// Eject can fail if issued too fast after writing data, which makes diskutil throw an error. Retry a few times with a delay to mitigate this.
|
|
RunProcess("diskutil", $"eject {diskIdentifier}", retryCount: 3);
|
|
var reattachoutput = RunProcess("hdiutil", $"attach -nomount -noautofsck -readonly \"{imagePath}\"");
|
|
if (tableType == PartitionTableType.Unknown)
|
|
return reattachoutput.Split('\n').First().Trim();
|
|
else
|
|
return reattachoutput
|
|
.Split('\n')
|
|
.Select(x => x.Trim()
|
|
.Split(' ')
|
|
.Where(y => !string.IsNullOrEmpty(y))
|
|
.Select(y => y.Trim())
|
|
.ToArray()
|
|
)
|
|
.Where(x => x.Length > 0 && x[^1].EndsWith("_partition_scheme"))
|
|
.First().First();
|
|
}
|
|
|
|
public static string RunProcess(string fileName, string arguments, int retryCount = 0)
|
|
{
|
|
for (int i = 0; i <= retryCount; i++)
|
|
{
|
|
var psi = new ProcessStartInfo
|
|
{
|
|
FileName = fileName,
|
|
Arguments = arguments,
|
|
RedirectStandardOutput = true,
|
|
RedirectStandardError = true,
|
|
UseShellExecute = false,
|
|
CreateNoWindow = true
|
|
};
|
|
|
|
using var process = new Process { StartInfo = psi };
|
|
process.Start();
|
|
string output = process.StandardOutput.ReadToEnd();
|
|
string error = process.StandardError.ReadToEnd();
|
|
process.WaitForExit();
|
|
|
|
if (process.ExitCode != 0)
|
|
if (i < retryCount)
|
|
{
|
|
TestContext.Progress.WriteLine($"Warning: Process {fileName} with arguments {arguments} exited with code {process.ExitCode}. Retrying... Attempt {i + 1} of {retryCount}");
|
|
Thread.Sleep(500);
|
|
continue;
|
|
}
|
|
else
|
|
throw new InvalidOperationException($"Process {fileName} with arguments {arguments} exited with code {process.ExitCode}: {error}. Output: {output}");
|
|
|
|
return output;
|
|
}
|
|
|
|
// This should never be hit due to the retry loop logic, but is required to satisfy the compiler.
|
|
throw new InvalidOperationException($"Failed to run process {fileName} with arguments {arguments} after retries. This should not happen.");
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void Dispose()
|
|
{
|
|
// Nothing to dispose
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
}
|
|
}
|