From 2485009d5b2542b609fe223ad4e81f3d00a6b7fe Mon Sep 17 00:00:00 2001 From: Juster Zhu Date: Mon, 9 Feb 2026 00:33:29 +0800 Subject: [PATCH 1/5] add GeneralUpdate.Drivelution --- .../Configuration/DriverUpdateOptions.cs | 98 ++++ .../Exceptions/DriverUpdateExceptions.cs | 131 +++++ .../Abstractions/IDriverBackup.cs | 37 ++ .../Abstractions/IDriverValidator.cs | 47 ++ .../Abstractions/IGeneralDrivelution.cs | 59 +++ .../Abstractions/INetworkDownloader.cs | 29 ++ .../Abstractions/Models/DriverInfo.cs | 80 +++ .../Abstractions/Models/ErrorInfo.cs | 98 ++++ .../Abstractions/Models/UpdateResult.cs | 92 ++++ .../Abstractions/Models/UpdateStrategy.cs | 102 ++++ .../Core/DriverUpdaterFactory.cs | 163 +++++++ .../Core/Logging/LoggerConfigurator.cs | 98 ++++ .../Core/Utilities/CompatibilityChecker.cs | 183 +++++++ .../Core/Utilities/HashValidator.cs | 114 +++++ .../Core/Utilities/RestartHelper.cs | 193 ++++++++ .../Core/Utilities/VersionComparer.cs | 161 ++++++ .../GeneralDrivelution.cs | 161 ++++++ .../GeneralUpdate.Drivelution.csproj | 21 + .../Linux/Helpers/LinuxPermissionHelper.cs | 165 +++++++ .../Linux/Helpers/LinuxSignatureHelper.cs | 160 ++++++ .../Linux/Implementation/LinuxDriverBackup.cs | 127 +++++ .../Implementation/LinuxDriverValidator.cs | 66 +++ .../Implementation/LinuxGeneralDrivelution.cs | 362 ++++++++++++++ .../Implementation/MacOsGeneralDrivelution.cs | 146 ++++++ .../Helpers/WindowsPermissionHelper.cs | 144 ++++++ .../Windows/Helpers/WindowsSignatureHelper.cs | 151 ++++++ .../Implementation/WindowsDriverBackup.cs | 148 ++++++ .../Implementation/WindowsDriverValidator.cs | 130 +++++ .../WindowsGeneralDrivelution.cs | 460 ++++++++++++++++++ src/c#/GeneralUpdate.sln | 15 + 30 files changed, 3941 insertions(+) create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/Configuration/DriverUpdateOptions.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/Exceptions/DriverUpdateExceptions.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/IDriverBackup.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/IDriverValidator.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/IGeneralDrivelution.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/INetworkDownloader.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/Models/DriverInfo.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/Models/ErrorInfo.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/Models/UpdateResult.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Abstractions/Models/UpdateStrategy.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Core/Logging/LoggerConfigurator.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Core/Utilities/CompatibilityChecker.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Core/Utilities/HashValidator.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Core/Utilities/RestartHelper.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Core/Utilities/VersionComparer.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/GeneralUpdate.Drivelution.csproj create mode 100644 src/c#/GeneralUpdate.Drivelution/Linux/Helpers/LinuxPermissionHelper.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Linux/Helpers/LinuxSignatureHelper.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxDriverBackup.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxDriverValidator.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/MacOS/Implementation/MacOsGeneralDrivelution.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Windows/Helpers/WindowsPermissionHelper.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Windows/Helpers/WindowsSignatureHelper.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverBackup.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverValidator.cs create mode 100644 src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Configuration/DriverUpdateOptions.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Configuration/DriverUpdateOptions.cs new file mode 100644 index 00000000..0258ec1d --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/Configuration/DriverUpdateOptions.cs @@ -0,0 +1,98 @@ +namespace GeneralUpdate.Drivelution.Abstractions.Configuration; + +/// +/// 驱动更新配置选项 +/// Driver update configuration options +/// +public class DriverUpdateOptions +{ + /// + /// 默认备份路径 + /// Default backup path + /// + public string DefaultBackupPath { get; set; } = "./DriverBackups"; + + /// + /// 日志级别（Debug/Info/Warn/Error/Fatal） + /// Log level (Debug/Info/Warn/Error/Fatal) + /// + public string LogLevel { get; set; } = "Info"; + + /// + /// 日志文件路径 + /// Log file path + /// + public string LogFilePath { get; set; } = "./Logs/driver-update-.log"; + + /// + /// 是否启用控制台日志 + /// Enable console logging + /// + public bool EnableConsoleLogging { get; set; } = true; + + /// + /// 是否启用文件日志 + /// Enable file logging + /// + public bool EnableFileLogging { get; set; } = true; + + /// + /// 默认重试次数 + /// Default retry count + /// + public int DefaultRetryCount { get; set; } = 3; + + /// + /// 默认重试间隔（秒） + /// Default retry interval (seconds) + /// + public int DefaultRetryIntervalSeconds { get; set; } = 5; + + /// + /// 默认超时时间（秒） + /// Default timeout (seconds) + /// + public int DefaultTimeoutSeconds { get; set; } = 300; + + /// + /// 是否在调试模式下跳过签名验证 + /// Skip signature validation in debug mode + /// + public bool DebugModeSkipSignature { get; set; } = false; + + /// + /// 是否在调试模式下跳过哈希验证 + /// Skip hash validation in debug mode + /// + public bool DebugModeSkipHash { get; set; } = false; + + /// + /// 权限校验失败时是否强制终止 + /// Force terminate on permission check failure + /// + public bool ForceTerminateOnPermissionFailure { get; set; } = true; + + /// + /// 是否自动清理旧备份（保留最近N个） + /// Auto cleanup old backups (keep recent N) + /// + public bool AutoCleanupBackups { get; set; } = true; + + /// + /// 保留的备份数量 + /// Number of backups to keep + /// + public int BackupsToKeep { get; set; } = 5; + + /// + /// 信任的证书指纹列表（用于签名验证） + /// Trusted certificate thumbprints (for signature validation) + /// + public List TrustedCertificateThumbprints { get; set; } = new(); + + /// + /// 信任的GPG公钥列表（Linux用） + /// Trusted GPG public keys (for Linux) + /// + public List TrustedGpgKeys { get; set; } = new(); +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Exceptions/DriverUpdateExceptions.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Exceptions/DriverUpdateExceptions.cs new file mode 100644 index 00000000..ee1f76bf --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/Exceptions/DriverUpdateExceptions.cs @@ -0,0 +1,131 @@ +namespace GeneralUpdate.Drivelution.Abstractions.Exceptions; + +/// +/// 驱动更新基础异常 +/// Base exception for driver update +/// +public class DriverUpdateException : Exception +{ + public string ErrorCode { get; set; } + public bool CanRetry { get; set; } + + public DriverUpdateException(string message, string errorCode = "DU_UNKNOWN", bool canRetry = false) + : base(message) + { + ErrorCode = errorCode; + CanRetry = canRetry; + } + + public DriverUpdateException(string message, Exception innerException, string errorCode = "DU_UNKNOWN", bool canRetry = false) + : base(message, innerException) + { + ErrorCode = errorCode; + CanRetry = canRetry; + } +} + +/// +/// 权限异常 +/// Permission exception +/// +public class DriverPermissionException : DriverUpdateException +{ + public DriverPermissionException(string message) + : base(message, "DU_PERMISSION_DENIED", false) + { + } + + public DriverPermissionException(string message, Exception innerException) + : base(message, innerException, "DU_PERMISSION_DENIED", false) + { + } +} + +/// +/// 校验失败异常 +/// Validation failed exception +/// +public class DriverValidationException : DriverUpdateException +{ + public string ValidationType { get; set; } + + public DriverValidationException(string message, string validationType) + : base(message, "DU_VALIDATION_FAILED", false) + { + ValidationType = validationType; + } + + public DriverValidationException(string message, string validationType, Exception innerException) + : base(message, innerException, "DU_VALIDATION_FAILED", false) + { + ValidationType = validationType; + } +} + +/// +/// 安装失败异常 +/// Installation failed exception +/// +public class DriverInstallationException : DriverUpdateException +{ + public DriverInstallationException(string message, bool canRetry = true) + : base(message, "DU_INSTALLATION_FAILED", canRetry) + { + } + + public DriverInstallationException(string message, Exception innerException, bool canRetry = true) + : base(message, innerException, "DU_INSTALLATION_FAILED", canRetry) + { + } +} + +/// +/// 备份失败异常 +/// Backup failed exception +/// +public class DriverBackupException : DriverUpdateException +{ + public DriverBackupException(string message) + : base(message, "DU_BACKUP_FAILED", true) + { + } + + public DriverBackupException(string message, Exception innerException) + : base(message, innerException, "DU_BACKUP_FAILED", true) + { + } +} + +/// +/// 回滚失败异常 +/// Rollback failed exception +/// +public class DriverRollbackException : DriverUpdateException +{ + public DriverRollbackException(string message) + : base(message, "DU_ROLLBACK_FAILED", false) + { + } + + public DriverRollbackException(string message, Exception innerException) + : base(message, innerException, "DU_ROLLBACK_FAILED", false) + { + } +} + +/// +/// 兼容性异常 +/// Compatibility exception +/// +public class DriverCompatibilityException : DriverUpdateException +{ + public DriverCompatibilityException(string message) + : base(message, "DU_COMPATIBILITY_FAILED", false) + { + } + + public DriverCompatibilityException(string message, Exception innerException) + : base(message, innerException, "DU_COMPATIBILITY_FAILED", false) + { + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/IDriverBackup.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/IDriverBackup.cs new file mode 100644 index 00000000..01567195 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/IDriverBackup.cs @@ -0,0 +1,37 @@ +namespace GeneralUpdate.Drivelution.Abstractions; + +/// +/// 驱动备份接口 +/// Driver backup interface +/// +public interface IDriverBackup +{ + /// + /// 异步备份驱动 + /// Backs up driver asynchronously + /// + /// 源路径 / Source path + /// 备份路径 / Backup path + /// 取消令牌 / Cancellation token + /// 备份结果 / Backup result + Task BackupAsync(string sourcePath, string backupPath, CancellationToken cancellationToken = default); + + /// + /// 异步恢复驱动 + /// Restores driver asynchronously + /// + /// 备份路径 / Backup path + /// 目标路径 / Target path + /// 取消令牌 / Cancellation token + /// 恢复结果 / Restore result + Task RestoreAsync(string backupPath, string targetPath, CancellationToken cancellationToken = default); + + /// + /// 异步删除备份 + /// Deletes backup asynchronously + /// + /// 备份路径 / Backup path + /// 取消令牌 / Cancellation token + /// 删除结果 / Delete result + Task DeleteBackupAsync(string backupPath, CancellationToken cancellationToken = default); +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/IDriverValidator.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/IDriverValidator.cs new file mode 100644 index 00000000..6e8e84b2 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/IDriverValidator.cs @@ -0,0 +1,47 @@ +using System.Diagnostics.CodeAnalysis; +using GeneralUpdate.Drivelution.Abstractions.Models; + +namespace GeneralUpdate.Drivelution.Abstractions; + +/// +/// 驱动验证器接口 +/// Driver validator interface +/// +public interface IDriverValidator +{ + /// + /// 异步验证驱动文件完整性（哈希校验） + /// Validates driver file integrity (hash validation) asynchronously + /// + /// 文件路径 / File path + /// 期望的哈希值 / Expected hash + /// 哈希算法 / Hash algorithm (SHA256, MD5) + /// 取消令牌 / Cancellation token + /// 验证是否通过 / Validation result + Task ValidateIntegrityAsync(string filePath, string expectedHash, string hashAlgorithm = "SHA256", CancellationToken cancellationToken = default); + + /// + /// 异步验证驱动数字签名 + /// Validates driver digital signature asynchronously + /// + /// 文件路径 / File path + /// 信任的发布者列表 / Trusted publishers list + /// 取消令牌 / Cancellation token + /// 验证是否通过 / Validation result + /// + /// Note: On Windows, this may require reflection for X509Certificate validation. + /// Platform-specific implementations should add appropriate AOT compatibility attributes. + /// + [RequiresUnreferencedCode("Signature validation may require runtime reflection on some platforms")] + [RequiresDynamicCode("Signature validation may require runtime code generation on some platforms")] + Task ValidateSignatureAsync(string filePath, IEnumerable trustedPublishers, CancellationToken cancellationToken = default); + + /// + /// 异步验证驱动兼容性 + /// Validates driver compatibility asynchronously + /// + /// 驱动信息 / Driver information + /// 取消令牌 / Cancellation token + /// 验证是否通过 / Validation result + Task ValidateCompatibilityAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default); +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/IGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/IGeneralDrivelution.cs new file mode 100644 index 00000000..e43aa145 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/IGeneralDrivelution.cs @@ -0,0 +1,59 @@ +using System.Diagnostics.CodeAnalysis; +using GeneralUpdate.Drivelution.Abstractions.Models; + +namespace GeneralUpdate.Drivelution.Abstractions; + +/// +/// 驱动更新器核心接口 +/// Core interface for driver updater +/// +public interface IGeneralDrivelution +{ + /// + /// 异步更新驱动 + /// Updates driver asynchronously + /// + /// 驱动信息 / Driver information + /// 更新策略 / Update strategy + /// 取消令牌 / Cancellation token + /// 更新结果 / Update result + /// + /// Note: Update process may include signature validation that requires reflection on some platforms. + /// + [RequiresUnreferencedCode("Update process may include signature validation that requires runtime reflection on some platforms")] + [RequiresDynamicCode("Update process may include signature validation that requires runtime code generation on some platforms")] + Task UpdateAsync(DriverInfo driverInfo, UpdateStrategy strategy, CancellationToken cancellationToken = default); + + /// + /// 异步验证驱动 + /// Validates driver asynchronously + /// + /// 驱动信息 / Driver information + /// 取消令牌 / Cancellation token + /// 验证是否通过 / Validation result + /// + /// Note: Includes signature validation that may require reflection on some platforms. + /// + [RequiresUnreferencedCode("Validation includes signature validation that may require runtime reflection on some platforms")] + [RequiresDynamicCode("Validation includes signature validation that may require runtime code generation on some platforms")] + Task ValidateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default); + + /// + /// 异步备份驱动 + /// Backs up driver asynchronously + /// + /// 驱动信息 / Driver information + /// 备份路径 / Backup path + /// 取消令牌 / Cancellation token + /// 备份结果 / Backup result + Task BackupAsync(DriverInfo driverInfo, string backupPath, CancellationToken cancellationToken = default); + + /// + /// 异步回滚驱动 + /// Rolls back driver asynchronously + /// + /// 备份路径 / Backup path + /// 取消令牌 / Cancellation token + /// 回滚结果 / Rollback result + Task RollbackAsync(string backupPath, CancellationToken cancellationToken = default); +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/INetworkDownloader.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/INetworkDownloader.cs new file mode 100644 index 00000000..2f758816 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/INetworkDownloader.cs @@ -0,0 +1,29 @@ +namespace GeneralUpdate.Drivelution.Abstractions; + +/// +/// 网络下载器接口（扩展点） +/// Network downloader interface (extension point) +/// +/// +/// 该接口预留用于未来扩展网络下载功能 +/// This interface is reserved for future network download functionality +/// +public interface INetworkDownloader +{ + /// + /// 异步下载驱动文件 + /// Downloads driver file asynchronously + /// + /// 下载地址 / Download URL + /// 目标路径 / Target path + /// 下载进度回调 / Download progress callback + /// 取消令牌 / Cancellation token + /// 下载结果 / Download result + Task DownloadAsync(string url, string targetPath, IProgress? progress = null, CancellationToken cancellationToken = default); + + /// + /// 取消下载 + /// Cancels download + /// + void CancelDownload(); +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/DriverInfo.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/DriverInfo.cs new file mode 100644 index 00000000..3c44ec3a --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/DriverInfo.cs @@ -0,0 +1,80 @@ +namespace GeneralUpdate.Drivelution.Abstractions.Models; + +/// +/// 驱动信息模型 +/// Driver information model +/// +public class DriverInfo +{ + /// + /// 驱动名称 + /// Driver name + /// + public string Name { get; set; } = string.Empty; + + /// + /// 驱动版本（遵循SemVer 2.0规范） + /// Driver version (follows SemVer 2.0 specification) + /// + public string Version { get; set; } = string.Empty; + + /// + /// 驱动文件路径 + /// Driver file path + /// + public string FilePath { get; set; } = string.Empty; + + /// + /// 适配操作系统 + /// Supported operating system + /// + public string TargetOS { get; set; } = string.Empty; + + /// + /// 适配系统架构（x86, x64, ARM, ARM64） + /// Supported system architecture (x86, x64, ARM, ARM64) + /// + public string Architecture { get; set; } = string.Empty; + + /// + /// 硬件ID（Windows硬件ID或Linux PCI/USB设备ID） + /// Hardware ID (Windows hardware ID or Linux PCI/USB device ID) + /// + public string HardwareId { get; set; } = string.Empty; + + /// + /// 文件哈希值（用于完整性校验） + /// File hash (for integrity validation) + /// + public string Hash { get; set; } = string.Empty; + + /// + /// 哈希算法（SHA256, MD5） + /// Hash algorithm (SHA256, MD5) + /// + public string HashAlgorithm { get; set; } = "SHA256"; + + /// + /// 信任的发布者列表 + /// Trusted publishers list + /// + public List TrustedPublishers { get; set; } = new(); + + /// + /// 驱动描述 + /// Driver description + /// + public string Description { get; set; } = string.Empty; + + /// + /// 驱动发布日期 + /// Driver release date + /// + public DateTime ReleaseDate { get; set; } + + /// + /// 附加元数据 + /// Additional metadata + /// + public Dictionary Metadata { get; set; } = new(); +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/ErrorInfo.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/ErrorInfo.cs new file mode 100644 index 00000000..b3142202 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/ErrorInfo.cs @@ -0,0 +1,98 @@ +namespace GeneralUpdate.Drivelution.Abstractions.Models; + +/// +/// 错误信息模型 +/// Error information model +/// +public class ErrorInfo +{ + /// + /// 错误码 + /// Error code + /// + public string Code { get; set; } = string.Empty; + + /// + /// 错误类型 + /// Error type + /// + public ErrorType Type { get; set; } + + /// + /// 错误消息 + /// Error message + /// + public string Message { get; set; } = string.Empty; + + /// + /// 详细错误信息 + /// Detailed error information + /// + public string Details { get; set; } = string.Empty; + + /// + /// 异常堆栈跟踪 + /// Exception stack trace + /// + public string? StackTrace { get; set; } + + /// + /// 内部异常 + /// Inner exception + /// + public Exception? InnerException { get; set; } + + /// + /// 错误发生时间 + /// Error occurrence time + /// + public DateTime Timestamp { get; set; } = DateTime.UtcNow; + + /// + /// 是否可以重试 + /// Whether retry is possible + /// + public bool CanRetry { get; set; } + + /// + /// 建议的处理方式 + /// Suggested resolution + /// + public string SuggestedResolution { get; set; } = string.Empty; +} + +/// +/// 错误类型枚举 +/// Error type enumeration +/// +public enum ErrorType +{ + /// 权限不足 / Insufficient permission + PermissionDenied, + /// 签名验证失败 / Signature validation failed + SignatureValidationFailed, + /// 哈希验证失败 / Hash validation failed + HashValidationFailed, + /// 兼容性验证失败 / Compatibility validation failed + CompatibilityValidationFailed, + /// 文件不存在 / File not found + FileNotFound, + /// 文件已损坏 / File corrupted + FileCorrupted, + /// 备份失败 / Backup failed + BackupFailed, + /// 安装失败 / Installation failed + InstallationFailed, + /// 回滚失败 / Rollback failed + RollbackFailed, + /// 网络错误 / Network error + NetworkError, + /// 超时 / Timeout + Timeout, + /// 用户取消 / User cancelled + UserCancelled, + /// 系统不支持 / System not supported + SystemNotSupported, + /// 未知错误 / Unknown error + Unknown +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/UpdateResult.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/UpdateResult.cs new file mode 100644 index 00000000..7bf38fdb --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/UpdateResult.cs @@ -0,0 +1,92 @@ +namespace GeneralUpdate.Drivelution.Abstractions.Models; + +/// +/// 更新结果模型 +/// Update result model +/// +public class UpdateResult +{ + /// + /// 更新是否成功 + /// Whether update succeeded + /// + public bool Success { get; set; } + + /// + /// 更新状态 + /// Update status + /// + public UpdateStatus Status { get; set; } + + /// + /// 错误信息 + /// Error information + /// + public ErrorInfo? Error { get; set; } + + /// + /// 更新开始时间 + /// Update start time + /// + public DateTime StartTime { get; set; } + + /// + /// 更新结束时间 + /// Update end time + /// + public DateTime EndTime { get; set; } + + /// + /// 更新耗时（毫秒） + /// Update duration (milliseconds) + /// + public long DurationMs => (long)(EndTime - StartTime).TotalMilliseconds; + + /// + /// 备份路径（如果有备份） + /// Backup path (if backed up) + /// + public string? BackupPath { get; set; } + + /// + /// 是否已回滚 + /// Whether rolled back + /// + public bool RolledBack { get; set; } + + /// + /// 附加消息 + /// Additional message + /// + public string Message { get; set; } = string.Empty; + + /// + /// 更新步骤日志 + /// Update step logs + /// + public List StepLogs { get; set; } = new(); +} + +/// +/// 更新状态枚举 +/// Update status enumeration +/// +public enum UpdateStatus +{ + /// 未开始 / Not started + NotStarted, + /// 验证中 / Validating + Validating, + /// 备份中 / Backing up + BackingUp, + /// 更新中 / Updating + Updating, + /// 验证更新结果 / Verifying update + Verifying, + /// 成功 / Succeeded + Succeeded, + /// 失败 / Failed + Failed, + /// 已回滚 / Rolled back + RolledBack +} diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/UpdateStrategy.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/UpdateStrategy.cs new file mode 100644 index 00000000..c55c5461 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/Models/UpdateStrategy.cs @@ -0,0 +1,102 @@ +namespace GeneralUpdate.Drivelution.Abstractions.Models; + +/// +/// 更新策略模型 +/// Update strategy model +/// +public class UpdateStrategy +{ + /// + /// 更新模式（全量更新/增量更新） + /// Update mode (Full/Incremental) + /// + public UpdateMode Mode { get; set; } = UpdateMode.Full; + + /// + /// 是否强制更新（强制更新不允许用户取消） + /// Force update (forced update cannot be cancelled by user) + /// + public bool ForceUpdate { get; set; } = false; + + /// + /// 是否需要备份 + /// Whether backup is required + /// + public bool RequireBackup { get; set; } = true; + + /// + /// 备份路径 + /// Backup path + /// + public string BackupPath { get; set; } = string.Empty; + + /// + /// 失败重试次数 + /// Retry count on failure + /// + public int RetryCount { get; set; } = 3; + + /// + /// 重试间隔（秒） + /// Retry interval (seconds) + /// + public int RetryIntervalSeconds { get; set; } = 5; + + /// + /// 更新优先级（用于分批更新） + /// Update priority (for batch updates) + /// + public int Priority { get; set; } = 0; + + /// + /// 更新完成后是否需要重启 + /// Whether restart is required after update + /// + public RestartMode RestartMode { get; set; } = RestartMode.Prompt; + + /// + /// 是否跳过签名验证（仅调试模式） + /// Skip signature validation (debug mode only) + /// + public bool SkipSignatureValidation { get; set; } = false; + + /// + /// 是否跳过哈希验证（仅调试模式） + /// Skip hash validation (debug mode only) + /// + public bool SkipHashValidation { get; set; } = false; + + /// + /// 超时时间（秒） + /// Timeout (seconds) + /// + public int TimeoutSeconds { get; set; } = 300; +} + +/// +/// 更新模式枚举 +/// Update mode enumeration +/// +public enum UpdateMode +{ + /// 全量更新 / Full update + Full, + /// 增量更新 / Incremental update + Incremental +} + +/// +/// 重启模式枚举 +/// Restart mode enumeration +/// +public enum RestartMode +{ + /// 不需要重启 / No restart required + None, + /// 提示用户重启 / Prompt user to restart + Prompt, + /// 延迟重启 / Delayed restart + Delayed, + /// 立即重启 / Immediate restart + Immediate +} diff --git a/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs b/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs new file mode 100644 index 00000000..4794c717 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs @@ -0,0 +1,163 @@ +using System.Runtime.InteropServices; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Configuration; +using GeneralUpdate.Drivelution.Windows.Implementation; +using GeneralUpdate.Drivelution.Linux.Implementation; +using GeneralUpdate.Drivelution.MacOS.Implementation; +using Serilog; + +namespace GeneralUpdate.Drivelution.Core; + +/// +/// 驱动更新器工厂类 - 自动检测平台并创建相应的实现 +/// Driver updater factory - Automatically detects platform and creates appropriate implementation +/// +public static class DriverUpdaterFactory +{ + /// + /// 创建适合当前平台的驱动更新器 + /// Creates a driver updater suitable for the current platform + /// + /// 日志记录器 / Logger + /// 配置选项（可选）/ Configuration options (optional) + /// 平台特定的驱动更新器实现 / Platform-specific driver updater implementation + /// 当前平台不支持时抛出 / Thrown when current platform is not supported + public static IGeneralDrivelution Create(ILogger? logger = null, DriverUpdateOptions? options = null) + { + // Use default logger if not provided + logger ??= CreateDefaultLogger(options); + + // Detect platform and create appropriate implementation + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + logger.Information("Detected Windows platform, creating WindowsGeneralDrivelution"); + var validator = new WindowsDriverValidator(logger); + var backup = new WindowsDriverBackup(logger); + return new WindowsGeneralDrivelution(logger, validator, backup); + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + logger.Information("Detected Linux platform, creating LinuxGeneralDrivelution"); + var validator = new LinuxDriverValidator(logger); + var backup = new LinuxDriverBackup(logger); + return new LinuxGeneralDrivelution(logger, validator, backup); + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + logger.Warning("MacOS platform detected but not yet implemented"); + throw new PlatformNotSupportedException( + "MacOS driver update is not yet implemented. " + + "This is a placeholder for future MacOS support. " + + "Current platform: macOS"); + } + else + { + var osDescription = RuntimeInformation.OSDescription; + logger.Error("Unsupported platform detected: {Platform}", osDescription); + throw new PlatformNotSupportedException( + $"Current platform '{osDescription}' is not supported. " + + "Supported platforms: Windows (8+), Linux (Ubuntu 18.04+, CentOS 7+, Debian 10+)"); + } + } + + /// + /// 创建适合当前平台的驱动验证器 + /// Creates a driver validator suitable for the current platform + /// + /// 日志记录器 / Logger + /// 平台特定的驱动验证器实现 / Platform-specific driver validator implementation + public static IDriverValidator CreateValidator(ILogger? logger = null) + { + logger ??= CreateDefaultLogger(); + + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + return new WindowsDriverValidator(logger); + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + return new LinuxDriverValidator(logger); + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + throw new PlatformNotSupportedException("MacOS driver validator is not yet implemented"); + } + else + { + throw new PlatformNotSupportedException($"Platform not supported: {RuntimeInformation.OSDescription}"); + } + } + + /// + /// 创建适合当前平台的驱动备份管理器 + /// Creates a driver backup manager suitable for the current platform + /// + /// 日志记录器 / Logger + /// 平台特定的驱动备份实现 / Platform-specific driver backup implementation + public static IDriverBackup CreateBackup(ILogger? logger = null) + { + logger ??= CreateDefaultLogger(); + + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + return new WindowsDriverBackup(logger); + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + return new LinuxDriverBackup(logger); + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + throw new PlatformNotSupportedException("MacOS driver backup is not yet implemented"); + } + else + { + throw new PlatformNotSupportedException($"Platform not supported: {RuntimeInformation.OSDescription}"); + } + } + + /// + /// 获取当前平台名称 + /// Gets the current platform name + /// + /// 平台名称 / Platform name + public static string GetCurrentPlatform() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + return "Windows"; + else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + return "Linux"; + else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + return "MacOS"; + else + return "Unknown"; + } + + /// + /// 检查当前平台是否支持 + /// Checks if the current platform is supported + /// + /// 是否支持 / Whether supported + public static bool IsPlatformSupported() + { + return RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || + RuntimeInformation.IsOSPlatform(OSPlatform.Linux); + // MacOS is planned but not yet implemented + } + + /// + /// 创建默认日志记录器 + /// Creates a default logger + /// + private static ILogger CreateDefaultLogger(DriverUpdateOptions? options = null) + { + if (options != null) + { + return Logging.LoggerConfigurator.ConfigureLogger(options); + } + else + { + return Logging.LoggerConfigurator.CreateDefaultLogger(); + } + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Core/Logging/LoggerConfigurator.cs b/src/c#/GeneralUpdate.Drivelution/Core/Logging/LoggerConfigurator.cs new file mode 100644 index 00000000..9bf76232 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Core/Logging/LoggerConfigurator.cs @@ -0,0 +1,98 @@ +using Serilog; +using Serilog.Events; +using GeneralUpdate.Drivelution.Abstractions.Configuration; + +namespace GeneralUpdate.Drivelution.Core.Logging; + +/// +/// 日志配置器 +/// Logger configurator +/// +public static class LoggerConfigurator +{ + /// + /// 配置日志器 + /// Configures logger + /// + /// 驱动更新配置选项 / Driver update configuration options + /// 配置好的日志器 / Configured logger + public static ILogger ConfigureLogger(DriverUpdateOptions options) + { + if (options == null) + { + throw new ArgumentNullException(nameof(options)); + } + + var loggerConfig = new LoggerConfiguration(); + + // Set log level + var logLevel = ParseLogLevel(options.LogLevel); + loggerConfig.MinimumLevel.Is(logLevel); + + // Configure console sink + if (options.EnableConsoleLogging) + { + loggerConfig.WriteTo.Console( + outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}"); + } + + // Configure file sink + if (options.EnableFileLogging) + { + var logPath = string.IsNullOrWhiteSpace(options.LogFilePath) + ? "./Logs/driver-update-.log" + : options.LogFilePath; + + loggerConfig.WriteTo.File( + logPath, + rollingInterval: RollingInterval.Day, + outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff} {Level:u3}] {Message:lj}{NewLine}{Exception}", + retainedFileCountLimit: 30, + fileSizeLimitBytes: 10 * 1024 * 1024); // 10MB per file + } + + // Enrich with context information + loggerConfig.Enrich.FromLogContext(); + + return loggerConfig.CreateLogger(); + } + + /// + /// 解析日志级别 + /// Parses log level + /// + /// 日志级别字符串 / Log level string + /// 日志事件级别 / Log event level + private static LogEventLevel ParseLogLevel(string logLevel) + { + return logLevel?.ToUpperInvariant() switch + { + "DEBUG" or "VERBOSE" => LogEventLevel.Debug, + "INFO" or "INFORMATION" => LogEventLevel.Information, + "WARN" or "WARNING" => LogEventLevel.Warning, + "ERROR" => LogEventLevel.Error, + "FATAL" or "CRITICAL" => LogEventLevel.Fatal, + _ => LogEventLevel.Information + }; + } + + /// + /// 创建默认日志器 + /// Creates default logger + /// + /// 默认配置的日志器 / Logger with default configuration + public static ILogger CreateDefaultLogger() + { + return new LoggerConfiguration() + .MinimumLevel.Information() + .WriteTo.Console( + outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}") + .WriteTo.File( + "./Logs/driver-update-.log", + rollingInterval: RollingInterval.Day, + outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff} {Level:u3}] {Message:lj}{NewLine}{Exception}", + retainedFileCountLimit: 30) + .Enrich.FromLogContext() + .CreateLogger(); + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Core/Utilities/CompatibilityChecker.cs b/src/c#/GeneralUpdate.Drivelution/Core/Utilities/CompatibilityChecker.cs new file mode 100644 index 00000000..2b5a37fb --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Core/Utilities/CompatibilityChecker.cs @@ -0,0 +1,183 @@ +using System.Runtime.InteropServices; +using GeneralUpdate.Drivelution.Abstractions.Models; + +namespace GeneralUpdate.Drivelution.Core.Utilities; + +/// +/// 兼容性检查工具类 +/// Compatibility checker utility +/// +public static class CompatibilityChecker +{ + /// + /// 异步检查驱动兼容性 + /// Checks driver compatibility asynchronously + /// + /// 驱动信息 / Driver information + /// 取消令牌 / Cancellation token + /// 是否兼容 / Whether compatible + public static Task CheckCompatibilityAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default) + { + return Task.Run(() => CheckCompatibility(driverInfo), cancellationToken); + } + + /// + /// 检查驱动兼容性 + /// Checks driver compatibility + /// + /// 驱动信息 / Driver information + /// 是否兼容 / Whether compatible + public static bool CheckCompatibility(DriverInfo driverInfo) + { + if (driverInfo == null) + { + throw new ArgumentNullException(nameof(driverInfo)); + } + + // Check OS compatibility + if (!IsOSCompatible(driverInfo.TargetOS)) + { + return false; + } + + // Check architecture compatibility + if (!IsArchitectureCompatible(driverInfo.Architecture)) + { + return false; + } + + return true; + } + + /// + /// 获取当前操作系统名称 + /// Gets current operating system name + /// + public static string GetCurrentOS() + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + return "Windows"; + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + return "Linux"; + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + return "MacOS"; + } + else + { + return "Unknown"; + } + } + + /// + /// 获取当前系统架构 + /// Gets current system architecture + /// + public static string GetCurrentArchitecture() + { + return RuntimeInformation.ProcessArchitecture.ToString(); + } + + /// + /// 获取系统版本信息 + /// Gets system version information + /// + public static string GetSystemVersion() + { + return Environment.OSVersion.ToString(); + } + + /// + /// 检查操作系统是否兼容 + /// Checks if OS is compatible + /// + private static bool IsOSCompatible(string targetOS) + { + if (string.IsNullOrWhiteSpace(targetOS)) + { + // If no target OS specified, assume compatible + return true; + } + + var currentOS = GetCurrentOS(); + return targetOS.Contains(currentOS, StringComparison.OrdinalIgnoreCase); + } + + /// + /// 检查架构是否兼容 + /// Checks if architecture is compatible + /// + private static bool IsArchitectureCompatible(string targetArchitecture) + { + if (string.IsNullOrWhiteSpace(targetArchitecture)) + { + // If no target architecture specified, assume compatible + return true; + } + + var currentArch = GetCurrentArchitecture(); + + // Handle common architecture aliases + var normalizedTarget = NormalizeArchitecture(targetArchitecture); + var normalizedCurrent = NormalizeArchitecture(currentArch); + + return normalizedTarget.Equals(normalizedCurrent, StringComparison.OrdinalIgnoreCase); + } + + /// + /// 标准化架构名称 + /// Normalizes architecture name + /// + private static string NormalizeArchitecture(string architecture) + { + return architecture.ToUpperInvariant() switch + { + "X64" or "AMD64" or "X86_64" => "X64", + "X86" or "I386" or "I686" => "X86", + "ARM64" or "AARCH64" => "ARM64", + "ARM" or "ARMV7" => "ARM", + _ => architecture.ToUpperInvariant() + }; + } + + /// + /// 获取详细的兼容性报告 + /// Gets detailed compatibility report + /// + public static CompatibilityReport GetCompatibilityReport(DriverInfo driverInfo) + { + var report = new CompatibilityReport + { + CurrentOS = GetCurrentOS(), + CurrentArchitecture = GetCurrentArchitecture(), + SystemVersion = GetSystemVersion(), + TargetOS = driverInfo.TargetOS, + TargetArchitecture = driverInfo.Architecture, + OSCompatible = IsOSCompatible(driverInfo.TargetOS), + ArchitectureCompatible = IsArchitectureCompatible(driverInfo.Architecture) + }; + + report.OverallCompatible = report.OSCompatible && report.ArchitectureCompatible; + return report; + } +} + +/// +/// 兼容性报告 +/// Compatibility report +/// +public class CompatibilityReport +{ + public string CurrentOS { get; set; } = string.Empty; + public string CurrentArchitecture { get; set; } = string.Empty; + public string SystemVersion { get; set; } = string.Empty; + public string TargetOS { get; set; } = string.Empty; + public string TargetArchitecture { get; set; } = string.Empty; + public bool OSCompatible { get; set; } + public bool ArchitectureCompatible { get; set; } + public bool OverallCompatible { get; set; } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Core/Utilities/HashValidator.cs b/src/c#/GeneralUpdate.Drivelution/Core/Utilities/HashValidator.cs new file mode 100644 index 00000000..ceb4bc0b --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Core/Utilities/HashValidator.cs @@ -0,0 +1,114 @@ +using System.Security.Cryptography; +using System.Text; + +namespace GeneralUpdate.Drivelution.Core.Utilities; + +/// +/// 哈希验证工具类 +/// Hash validation utility +/// +public static class HashValidator +{ + /// + /// 异步计算文件哈希值 + /// Calculates file hash asynchronously + /// + /// 文件路径 / File path + /// 哈希算法（SHA256, MD5）/ Hash algorithm (SHA256, MD5) + /// 取消令牌 / Cancellation token + /// 哈希值（十六进制字符串）/ Hash value (hex string) + public static async Task ComputeHashAsync(string filePath, string hashAlgorithm = "SHA256", CancellationToken cancellationToken = default) + { + if (!File.Exists(filePath)) + { + throw new FileNotFoundException($"File not found: {filePath}"); + } + + using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true); + + byte[] hashBytes; + switch (hashAlgorithm.ToUpperInvariant()) + { + case "SHA256": + hashBytes = await SHA256.HashDataAsync(stream, cancellationToken); + break; + case "MD5": +#pragma warning disable CA5351 // Do Not Use Broken Cryptographic Algorithms (MD5 supported for compatibility) + hashBytes = await MD5.HashDataAsync(stream, cancellationToken); +#pragma warning restore CA5351 + break; + default: + throw new ArgumentException($"Unsupported hash algorithm: {hashAlgorithm}"); + } + + return ByteArrayToHexString(hashBytes); + } + + /// + /// 异步验证文件哈希值 + /// Validates file hash asynchronously + /// + /// 文件路径 / File path + /// 期望的哈希值 / Expected hash + /// 哈希算法 / Hash algorithm + /// 取消令牌 / Cancellation token + /// 是否匹配 / Whether it matches + public static async Task ValidateHashAsync(string filePath, string expectedHash, string hashAlgorithm = "SHA256", CancellationToken cancellationToken = default) + { + if (string.IsNullOrWhiteSpace(expectedHash)) + { + throw new ArgumentException("Expected hash cannot be null or empty"); + } + + var actualHash = await ComputeHashAsync(filePath, hashAlgorithm, cancellationToken); + return string.Equals(actualHash, expectedHash, StringComparison.OrdinalIgnoreCase); + } + + /// + /// 计算字符串哈希值 + /// Calculates string hash + /// + /// 输入字符串 / Input string + /// 哈希算法 / Hash algorithm + /// 哈希值（十六进制字符串）/ Hash value (hex string) + public static string ComputeStringHash(string input, string hashAlgorithm = "SHA256") + { + if (string.IsNullOrEmpty(input)) + { + throw new ArgumentException("Input string cannot be null or empty"); + } + + var bytes = Encoding.UTF8.GetBytes(input); + byte[] hashBytes; + + switch (hashAlgorithm.ToUpperInvariant()) + { + case "SHA256": + hashBytes = SHA256.HashData(bytes); + break; + case "MD5": +#pragma warning disable CA5351 + hashBytes = MD5.HashData(bytes); +#pragma warning restore CA5351 + break; + default: + throw new ArgumentException($"Unsupported hash algorithm: {hashAlgorithm}"); + } + + return ByteArrayToHexString(hashBytes); + } + + /// + /// 将字节数组转换为十六进制字符串 + /// Converts byte array to hex string + /// + private static string ByteArrayToHexString(byte[] bytes) + { + var sb = new StringBuilder(bytes.Length * 2); + foreach (var b in bytes) + { + sb.AppendFormat("{0:x2}", b); + } + return sb.ToString(); + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Core/Utilities/RestartHelper.cs b/src/c#/GeneralUpdate.Drivelution/Core/Utilities/RestartHelper.cs new file mode 100644 index 00000000..4977c451 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Core/Utilities/RestartHelper.cs @@ -0,0 +1,193 @@ +using System.Diagnostics; +using System.Runtime.InteropServices; +using GeneralUpdate.Drivelution.Abstractions.Models; + +namespace GeneralUpdate.Drivelution.Core.Utilities; + +/// +/// 重启助手工具类 +/// Restart helper utility +/// +public static class RestartHelper +{ + /// + /// 根据重启模式执行重启操作 + /// Executes restart operation based on restart mode + /// + /// 重启模式 / Restart mode + /// 延迟秒数（仅用于延迟重启）/ Delay seconds (only for delayed restart) + /// 提示消息 / Prompt message + /// 是否成功 / Whether successful + public static async Task HandleRestartAsync(RestartMode mode, int delaySeconds = 30, string message = "") + { + switch (mode) + { + case RestartMode.None: + return true; + + case RestartMode.Prompt: + return PromptUserForRestart(message); + + case RestartMode.Delayed: + await Task.Delay(TimeSpan.FromSeconds(delaySeconds)); + return await RestartSystemAsync(); + + case RestartMode.Immediate: + return await RestartSystemAsync(); + + default: + return false; + } + } + + /// + /// 提示用户重启 + /// Prompts user for restart + /// + /// 提示消息 / Prompt message + /// 用户是否选择重启 / Whether user chose to restart + public static bool PromptUserForRestart(string message = "") + { + var promptMessage = string.IsNullOrWhiteSpace(message) + ? "Driver update requires system restart. Do you want to restart now? (Y/N)" + : message; + + Console.WriteLine(promptMessage); + // This is a simplified implementation. In a real application, you might use a GUI dialog. + // For now, we'll just log the message and return false (user needs to manually restart) + return false; + } + + /// + /// 异步重启系统 + /// Restarts system asynchronously + /// + /// 是否成功启动重启命令 / Whether restart command was successfully initiated + public static async Task RestartSystemAsync() + { + try + { + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + return await RestartWindowsAsync(); + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) + { + return await RestartLinuxAsync(); + } + else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + return await RestartMacOSAsync(); + } + else + { + throw new PlatformNotSupportedException("Current platform is not supported for restart"); + } + } + catch (Exception ex) + { + Console.WriteLine($"Failed to restart system: {ex.Message}"); + return false; + } + } + + /// + /// 重启Windows系统 + /// Restarts Windows system + /// + private static async Task RestartWindowsAsync() + { + var startInfo = new ProcessStartInfo + { + FileName = "shutdown", + Arguments = "/r /t 0", + UseShellExecute = false, + CreateNoWindow = true + }; + + using var process = Process.Start(startInfo); + if (process != null) + { + await process.WaitForExitAsync(); + return process.ExitCode == 0; + } + + return false; + } + + /// + /// 重启Linux系统 + /// Restarts Linux system + /// + private static async Task RestartLinuxAsync() + { + var startInfo = new ProcessStartInfo + { + FileName = "shutdown", + Arguments = "-r now", + UseShellExecute = false, + CreateNoWindow = true + }; + + using var process = Process.Start(startInfo); + if (process != null) + { + await process.WaitForExitAsync(); + return process.ExitCode == 0; + } + + return false; + } + + /// + /// 重启MacOS系统 + /// Restarts MacOS system + /// + private static async Task RestartMacOSAsync() + { + var startInfo = new ProcessStartInfo + { + FileName = "shutdown", + Arguments = "-r now", + UseShellExecute = false, + CreateNoWindow = true + }; + + using var process = Process.Start(startInfo); + if (process != null) + { + await process.WaitForExitAsync(); + return process.ExitCode == 0; + } + + return false; + } + + /// + /// 重启当前进程 + /// Restarts current process + /// + public static void RestartCurrentProcess() + { + var currentProcess = Process.GetCurrentProcess(); + var startInfo = new ProcessStartInfo + { + FileName = currentProcess.MainModule?.FileName ?? string.Empty, + UseShellExecute = true + }; + + Process.Start(startInfo); + Environment.Exit(0); + } + + /// + /// 检查是否需要重启 + /// Checks if restart is required + /// + /// 重启模式 / Restart mode + /// 是否需要重启 / Whether restart is required + public static bool IsRestartRequired(RestartMode mode) + { + return mode != RestartMode.None; + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Core/Utilities/VersionComparer.cs b/src/c#/GeneralUpdate.Drivelution/Core/Utilities/VersionComparer.cs new file mode 100644 index 00000000..4137966c --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Core/Utilities/VersionComparer.cs @@ -0,0 +1,161 @@ +using System.Text.RegularExpressions; + +namespace GeneralUpdate.Drivelution.Core.Utilities; + +/// +/// 版本比较工具类（遵循SemVer 2.0规范） +/// Version comparison utility (follows SemVer 2.0 specification) +/// +public static class VersionComparer +{ + private static readonly Regex SemVerRegex = new( + @"^(?0|[1-9]\d*)\.(?0|[1-9]\d*)\.(?0|[1-9]\d*)(?:-(?(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$", + RegexOptions.Compiled); + + /// + /// 比较两个版本号 + /// Compares two version numbers + /// + /// 版本1 / Version 1 + /// 版本2 / Version 2 + /// + /// 如果version1 > version2，返回1； + /// 如果version1 = version2，返回0； + /// 如果version1 < version2，返回-1 + /// Returns 1 if version1 > version2, 0 if equal, -1 if version1 < version2 + /// + public static int Compare(string version1, string version2) + { + if (string.IsNullOrWhiteSpace(version1) || string.IsNullOrWhiteSpace(version2)) + { + throw new ArgumentException("Version strings cannot be null or empty"); + } + + var v1 = ParseVersion(version1); + var v2 = ParseVersion(version2); + + // Compare major, minor, patch + if (v1.Major != v2.Major) + return v1.Major.CompareTo(v2.Major); + if (v1.Minor != v2.Minor) + return v1.Minor.CompareTo(v2.Minor); + if (v1.Patch != v2.Patch) + return v1.Patch.CompareTo(v2.Patch); + + // If both have no prerelease, they are equal + if (string.IsNullOrEmpty(v1.Prerelease) && string.IsNullOrEmpty(v2.Prerelease)) + return 0; + + // Version without prerelease is greater than version with prerelease + if (string.IsNullOrEmpty(v1.Prerelease)) + return 1; + if (string.IsNullOrEmpty(v2.Prerelease)) + return -1; + + // Compare prerelease identifiers + return ComparePrerelease(v1.Prerelease, v2.Prerelease); + } + + /// + /// 判断version1是否大于version2 + /// Checks if version1 is greater than version2 + /// + public static bool IsGreaterThan(string version1, string version2) + { + return Compare(version1, version2) > 0; + } + + /// + /// 判断version1是否小于version2 + /// Checks if version1 is less than version2 + /// + public static bool IsLessThan(string version1, string version2) + { + return Compare(version1, version2) < 0; + } + + /// + /// 判断version1是否等于version2 + /// Checks if version1 equals version2 + /// + public static bool IsEqual(string version1, string version2) + { + return Compare(version1, version2) == 0; + } + + /// + /// 验证版本号是否符合SemVer 2.0规范 + /// Validates if version string follows SemVer 2.0 specification + /// + public static bool IsValidSemVer(string version) + { + if (string.IsNullOrWhiteSpace(version)) + return false; + + return SemVerRegex.IsMatch(version); + } + + private static SemVerInfo ParseVersion(string version) + { + var match = SemVerRegex.Match(version); + if (!match.Success) + { + throw new FormatException($"Version '{version}' does not follow SemVer 2.0 format"); + } + + return new SemVerInfo + { + Major = int.Parse(match.Groups["major"].Value), + Minor = int.Parse(match.Groups["minor"].Value), + Patch = int.Parse(match.Groups["patch"].Value), + Prerelease = match.Groups["prerelease"].Value, + BuildMetadata = match.Groups["buildmetadata"].Value + }; + } + + private static int ComparePrerelease(string pre1, string pre2) + { + var parts1 = pre1.Split('.'); + var parts2 = pre2.Split('.'); + + int minLength = Math.Min(parts1.Length, parts2.Length); + + for (int i = 0; i < minLength; i++) + { + var isNum1 = int.TryParse(parts1[i], out int num1); + var isNum2 = int.TryParse(parts2[i], out int num2); + + if (isNum1 && isNum2) + { + if (num1 != num2) + return num1.CompareTo(num2); + } + else if (isNum1) + { + return -1; // Numeric identifier is less than alphanumeric + } + else if (isNum2) + { + return 1; // Alphanumeric is greater than numeric + } + else + { + int stringCompare = string.CompareOrdinal(parts1[i], parts2[i]); + if (stringCompare != 0) + return stringCompare; + } + } + + // Longer prerelease is greater + return parts1.Length.CompareTo(parts2.Length); + } + + private class SemVerInfo + { + public int Major { get; set; } + public int Minor { get; set; } + public int Patch { get; set; } + public string Prerelease { get; set; } = string.Empty; + public string BuildMetadata { get; set; } = string.Empty; + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs new file mode 100644 index 00000000..61380646 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs @@ -0,0 +1,161 @@ +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Configuration; +using GeneralUpdate.Drivelution.Abstractions.Models; +using GeneralUpdate.Drivelution.Core.Logging; +using GeneralUpdate.Drivelution.Core.Utilities; +using Serilog; + +namespace GeneralUpdate.Drivelution; + +/// +/// 驱动更新器统一入口类 - 提供优雅的API，自动适配平台 +/// Unified driver updater entry point - Provides elegant API with automatic platform adaptation +/// +/// +/// 使用示例 / Usage example: +/// +/// // 简单使用 - 自动检测平台 +/// // Simple usage - automatic platform detection +/// var updater = GeneralDrivelution.Create(); +/// var result = await updater.UpdateAsync(driverInfo, strategy); +/// +/// // 带配置使用 +/// // With configuration +/// var options = new DriverUpdateOptions { LogLevel = "Info" }; +/// var updater = GeneralDrivelution.Create(options); +/// var result = await updater.UpdateAsync(driverInfo, strategy); +/// +/// +public static class GeneralDrivelution +{ + /// + /// 创建驱动更新器实例（自动检测当前平台） + /// Creates a driver updater instance (automatically detects current platform) + /// + /// 配置选项（可选）/ Configuration options (optional) + /// 适配当前平台的驱动更新器 / Platform-adapted driver updater + /// 当前平台不支持时抛出 / Thrown when platform is not supported + public static IGeneralDrivelution Create(DriverUpdateOptions? options = null) + { + var logger = options != null + ? LoggerConfigurator.ConfigureLogger(options) + : LoggerConfigurator.CreateDefaultLogger(); + + return Core.DriverUpdaterFactory.Create(logger, options); + } + + /// + /// 创建驱动更新器实例（使用自定义日志记录器） + /// Creates a driver updater instance (with custom logger) + /// + /// 自定义日志记录器 / Custom logger + /// 配置选项（可选）/ Configuration options (optional) + /// 适配当前平台的驱动更新器 / Platform-adapted driver updater + public static IGeneralDrivelution Create(ILogger logger, DriverUpdateOptions? options = null) + { + return Core.DriverUpdaterFactory.Create(logger, options); + } + + /// + /// 快速更新驱动（使用默认配置） + /// Quick driver update (with default configuration) + /// + /// 驱动信息 / Driver information + /// 取消令牌 / Cancellation token + /// 更新结果 / Update result + public static async Task QuickUpdateAsync( + DriverInfo driverInfo, + CancellationToken cancellationToken = default) + { + var updater = Create(); + var strategy = new UpdateStrategy + { + RequireBackup = true, + RetryCount = 3, + RetryIntervalSeconds = 5 + }; + + return await updater.UpdateAsync(driverInfo, strategy, cancellationToken); + } + + /// + /// 快速更新驱动（带自定义策略） + /// Quick driver update (with custom strategy) + /// + /// 驱动信息 / Driver information + /// 更新策略 / Update strategy + /// 取消令牌 / Cancellation token + /// 更新结果 / Update result + public static async Task QuickUpdateAsync( + DriverInfo driverInfo, + UpdateStrategy strategy, + CancellationToken cancellationToken = default) + { + var updater = Create(); + return await updater.UpdateAsync(driverInfo, strategy, cancellationToken); + } + + /// + /// 验证驱动文件（自动选择平台验证器） + /// Validates driver file (automatically selects platform validator) + /// + /// 驱动信息 / Driver information + /// 取消令牌 / Cancellation token + /// 是否验证通过 / Whether validation passed + public static async Task ValidateAsync( + DriverInfo driverInfo, + CancellationToken cancellationToken = default) + { + var updater = Create(); + return await updater.ValidateAsync(driverInfo, cancellationToken); + } + + /// + /// 获取当前平台信息 + /// Gets current platform information + /// + /// 平台信息 / Platform information + public static PlatformInfo GetPlatformInfo() + { + return new PlatformInfo + { + Platform = Core.DriverUpdaterFactory.GetCurrentPlatform(), + IsSupported = Core.DriverUpdaterFactory.IsPlatformSupported(), + OperatingSystem = CompatibilityChecker.GetCurrentOS(), + Architecture = CompatibilityChecker.GetCurrentArchitecture(), + SystemVersion = CompatibilityChecker.GetSystemVersion() + }; + } +} + +/// +/// 平台信息 +/// Platform information +/// +public class PlatformInfo +{ + /// 平台名称 / Platform name + public string Platform { get; set; } = string.Empty; + + /// 是否支持 / Is supported + public bool IsSupported { get; set; } + + /// 操作系统 / Operating system + public string OperatingSystem { get; set; } = string.Empty; + + /// 系统架构 / Architecture + public string Architecture { get; set; } = string.Empty; + + /// 系统版本 / System version + public string SystemVersion { get; set; } = string.Empty; + + /// + /// 返回平台信息的字符串表示 + /// Returns string representation of platform information + /// + public override string ToString() + { + return $"{Platform} ({OperatingSystem}) - {Architecture} - {SystemVersion} - " + + $"Supported: {(IsSupported ? "Yes" : "No")}"; + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/GeneralUpdate.Drivelution.csproj b/src/c#/GeneralUpdate.Drivelution/GeneralUpdate.Drivelution.csproj new file mode 100644 index 00000000..a89c36c0 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/GeneralUpdate.Drivelution.csproj @@ -0,0 +1,21 @@ + + + + net8.0 + enable + enable + + true + + true + true + full + + + + + + + + + diff --git a/src/c#/GeneralUpdate.Drivelution/Linux/Helpers/LinuxPermissionHelper.cs b/src/c#/GeneralUpdate.Drivelution/Linux/Helpers/LinuxPermissionHelper.cs new file mode 100644 index 00000000..7a55c7c2 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Linux/Helpers/LinuxPermissionHelper.cs @@ -0,0 +1,165 @@ +using System.Diagnostics; +using System.Runtime.Versioning; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; + +namespace GeneralUpdate.Drivelution.Linux.Helpers; + +/// +/// Linux权限助手 +/// Linux permission helper +/// +[SupportedOSPlatform("linux")] +public static class LinuxPermissionHelper +{ + /// + /// 检查当前用户是否具有root权限 + /// Checks if current user has root privileges + /// + /// 是否具有root权限 / Whether has root privileges + public static bool IsRoot() + { + try + { + var userId = Environment.GetEnvironmentVariable("UID") ?? string.Empty; + if (userId == "0") + { + return true; + } + + // Alternative check using 'id' command + var startInfo = new ProcessStartInfo + { + FileName = "id", + Arguments = "-u", + UseShellExecute = false, + RedirectStandardOutput = true, + CreateNoWindow = true + }; + + using var process = Process.Start(startInfo); + if (process != null) + { + var output = process.StandardOutput.ReadToEnd().Trim(); + process.WaitForExit(); + return output == "0"; + } + + return false; + } + catch (Exception) + { + // Failed to check root privileges + return false; + } + } + + /// + /// 检查当前用户是否可以使用sudo + /// Checks if current user can use sudo + /// + /// 是否可以使用sudo / Whether can use sudo + public static async Task CanUseSudoAsync() + { + try + { + var startInfo = new ProcessStartInfo + { + FileName = "sudo", + Arguments = "-n true", + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + CreateNoWindow = true + }; + + using var process = Process.Start(startInfo); + if (process != null) + { + await process.WaitForExitAsync(); + return process.ExitCode == 0; + } + + return false; + } + catch (Exception) + { + // Failed to check sudo privileges + return false; + } + } + + /// + /// 确保root权限，如无则抛出异常 + /// Ensures root privileges, throws exception if not + /// + public static void EnsureRoot() + { + if (!IsRoot()) + { + throw new DriverPermissionException( + "Root privileges are required to perform driver updates. " + + "Please run this application with sudo or as root user."); + } + } + + /// + /// 确保sudo权限，如无则抛出异常 + /// Ensures sudo privileges, throws exception if not + /// + public static async Task EnsureSudoAsync() + { + if (IsRoot()) + { + return; + } + + if (!await CanUseSudoAsync()) + { + throw new DriverPermissionException( + "Sudo privileges are required to perform driver updates. " + + "Please ensure your user has sudo access."); + } + } + + /// + /// 使用sudo执行命令 + /// Executes command with sudo + /// + /// 命令 / Command + /// 参数 / Arguments + /// 是否成功 / Whether successful + public static async Task<(bool success, string output, string error)> ExecuteWithSudoAsync( + string command, + string arguments) + { + try + { + var startInfo = new ProcessStartInfo + { + FileName = "sudo", + Arguments = $"{command} {arguments}", + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + CreateNoWindow = true + }; + + using var process = Process.Start(startInfo); + if (process != null) + { + var output = await process.StandardOutput.ReadToEndAsync(); + var error = await process.StandardError.ReadToEndAsync(); + await process.WaitForExitAsync(); + + return (process.ExitCode == 0, output, error); + } + + return (false, string.Empty, "Failed to start process"); + } + catch (Exception ex) + { + // Failed to execute command with sudo + return (false, string.Empty, ex.Message); + } + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Linux/Helpers/LinuxSignatureHelper.cs b/src/c#/GeneralUpdate.Drivelution/Linux/Helpers/LinuxSignatureHelper.cs new file mode 100644 index 00000000..3696ddfc --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Linux/Helpers/LinuxSignatureHelper.cs @@ -0,0 +1,160 @@ +using System.Diagnostics; +using System.Runtime.Versioning; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; + + +namespace GeneralUpdate.Drivelution.Linux.Helpers; + +/// +/// Linux签名验证助手 +/// Linux signature validation helper +/// +[SupportedOSPlatform("linux")] +public static class LinuxSignatureHelper +{ + /// + /// 验证GPG签名 + /// Validates GPG signature + /// + /// 文件路径 / File path + /// 签名文件路径 / Signature file path + /// 信任的GPG公钥列表 / Trusted GPG public keys + /// 是否验证通过 / Whether validation succeeded + public static async Task ValidateGpgSignatureAsync( + string filePath, + string signaturePath, + IEnumerable trustedKeys) + { + if (!File.Exists(filePath)) + { + throw new FileNotFoundException($"File not found: {filePath}"); + } + + if (!File.Exists(signaturePath)) + { + // Signature file not found + return false; + } + + try + { + // Validating GPG signature for file: {FilePath} + + // Import trusted keys if provided + if (trustedKeys.Any()) + { + foreach (var key in trustedKeys) + { + await ImportGpgKeyAsync(key); + } + } + + // Verify signature + var startInfo = new ProcessStartInfo + { + FileName = "gpg", + Arguments = $"--verify \"{signaturePath}\" \"{filePath}\"", + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + CreateNoWindow = true + }; + + using var process = Process.Start(startInfo); + if (process != null) + { + var output = await process.StandardOutput.ReadToEndAsync(); + var error = await process.StandardError.ReadToEndAsync(); + await process.WaitForExitAsync(); + + // GPG verification output: {Output} // GPG outputs to stderr + + if (process.ExitCode == 0) + { + // GPG signature validation succeeded + return true; + } + else + { + // GPG signature validation failed + return false; + } + } + + return false; + } + catch (Exception ex) + { + // Failed to validate GPG signature + throw new DriverValidationException( + $"Failed to validate GPG signature: {ex.Message}", + "Signature", + ex); + } + } + + /// + /// 导入GPG公钥 + /// Imports GPG public key + /// + /// 公钥ID或文件路径 / Key ID or file path + private static async Task ImportGpgKeyAsync(string keyId) + { + try + { + string arguments; + if (File.Exists(keyId)) + { + // Import from file + arguments = $"--import \"{keyId}\""; + } + else + { + // Import from keyserver + arguments = $"--keyserver keyserver.ubuntu.com --recv-keys {keyId}"; + } + + var startInfo = new ProcessStartInfo + { + FileName = "gpg", + Arguments = arguments, + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + CreateNoWindow = true + }; + + using var process = Process.Start(startInfo); + if (process != null) + { + await process.WaitForExitAsync(); + return process.ExitCode == 0; + } + + return false; + } + catch (Exception) + { + // Failed to import GPG key + return false; + } + } + + /// + /// 检查文件是否有GPG签名 + /// Checks if file has GPG signature + /// + /// 文件路径 / File path + /// 是否有签名 / Whether has signature + public static bool HasGpgSignature(string filePath) + { + if (!File.Exists(filePath)) + { + return false; + } + + // Check for common signature file extensions + var signatureExtensions = new[] { ".sig", ".asc", ".sign" }; + return signatureExtensions.Any(ext => File.Exists(filePath + ext)); + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxDriverBackup.cs b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxDriverBackup.cs new file mode 100644 index 00000000..9cb1c698 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxDriverBackup.cs @@ -0,0 +1,127 @@ +using System.Runtime.Versioning; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; +using Serilog; + +namespace GeneralUpdate.Drivelution.Linux.Implementation; + +/// +/// Linux驱动备份实现 +/// Linux driver backup implementation +/// +[SupportedOSPlatform("linux")] +public class LinuxDriverBackup : IDriverBackup +{ + private readonly ILogger _logger; + + public LinuxDriverBackup(ILogger logger) + { + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + /// + public async Task BackupAsync( + string sourcePath, + string backupPath, + CancellationToken cancellationToken = default) + { + try + { + if (!File.Exists(sourcePath)) + { + throw new FileNotFoundException($"Source file not found: {sourcePath}"); + } + + var backupDir = Path.GetDirectoryName(backupPath); + if (!string.IsNullOrEmpty(backupDir) && !Directory.Exists(backupDir)) + { + Directory.CreateDirectory(backupDir); + } + + var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss"); + var fileName = Path.GetFileNameWithoutExtension(backupPath); + var extension = Path.GetExtension(backupPath); + var backupPathWithTimestamp = Path.Combine( + backupDir ?? string.Empty, + $"{fileName}_{timestamp}{extension}"); + + using (var sourceStream = new FileStream(sourcePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true)) + using (var destinationStream = new FileStream(backupPathWithTimestamp, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, true)) + { + await sourceStream.CopyToAsync(destinationStream, cancellationToken); + } + + _logger.Information("Backup completed: {BackupPath}", backupPathWithTimestamp); + return true; + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to backup driver"); + throw new DriverBackupException($"Failed to backup driver: {ex.Message}", ex); + } + } + + /// + public async Task RestoreAsync( + string backupPath, + string targetPath, + CancellationToken cancellationToken = default) + { + try + { + if (!File.Exists(backupPath)) + { + throw new FileNotFoundException($"Backup file not found: {backupPath}"); + } + + var targetDir = Path.GetDirectoryName(targetPath); + if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir)) + { + Directory.CreateDirectory(targetDir); + } + + if (File.Exists(targetPath)) + { + File.Move(targetPath, $"{targetPath}.old", true); + } + + using (var sourceStream = new FileStream(backupPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true)) + using (var destinationStream = new FileStream(targetPath, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, true)) + { + await sourceStream.CopyToAsync(destinationStream, cancellationToken); + } + + _logger.Information("Restore completed"); + return true; + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to restore driver"); + throw new DriverRollbackException($"Failed to restore driver: {ex.Message}", ex); + } + } + + /// + public async Task DeleteBackupAsync( + string backupPath, + CancellationToken cancellationToken = default) + { + return await Task.Run(() => + { + try + { + if (File.Exists(backupPath)) + { + File.Delete(backupPath); + return true; + } + return false; + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to delete backup"); + return false; + } + }, cancellationToken); + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxDriverValidator.cs b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxDriverValidator.cs new file mode 100644 index 00000000..b2f27996 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxDriverValidator.cs @@ -0,0 +1,66 @@ +using System.Diagnostics.CodeAnalysis; +using System.Runtime.Versioning; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Models; +using GeneralUpdate.Drivelution.Core.Utilities; +using GeneralUpdate.Drivelution.Linux.Helpers; +using Serilog; + +namespace GeneralUpdate.Drivelution.Linux.Implementation; + +/// +/// Linux驱动验证器实现 +/// Linux driver validator implementation +/// +[SupportedOSPlatform("linux")] +public class LinuxDriverValidator : IDriverValidator +{ + private readonly ILogger _logger; + + public LinuxDriverValidator(ILogger logger) + { + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + /// + public async Task ValidateIntegrityAsync( + string filePath, + string expectedHash, + string hashAlgorithm = "SHA256", + CancellationToken cancellationToken = default) + { + return await HashValidator.ValidateHashAsync(filePath, expectedHash, hashAlgorithm, cancellationToken); + } + + /// + [RequiresUnreferencedCode("Signature validation may require runtime reflection on some platforms")] + [RequiresDynamicCode("Signature validation may require runtime code generation on some platforms")] + public async Task ValidateSignatureAsync( + string filePath, + IEnumerable trustedPublishers, + CancellationToken cancellationToken = default) + { + // Check for GPG signature file + var signaturePath = filePath + ".sig"; + if (!File.Exists(signaturePath)) + { + signaturePath = filePath + ".asc"; + } + + if (File.Exists(signaturePath)) + { + return await LinuxSignatureHelper.ValidateGpgSignatureAsync(filePath, signaturePath, trustedPublishers); + } + + _logger.Warning("No signature file found for: {FilePath}", filePath); + return !trustedPublishers.Any(); // If no trusted publishers specified, accept unsigned + } + + /// + public async Task ValidateCompatibilityAsync( + DriverInfo driverInfo, + CancellationToken cancellationToken = default) + { + return await CompatibilityChecker.CheckCompatibilityAsync(driverInfo, cancellationToken); + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs new file mode 100644 index 00000000..710df524 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs @@ -0,0 +1,362 @@ +using System.Runtime.Versioning; +using System.Diagnostics.CodeAnalysis; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; +using GeneralUpdate.Drivelution.Abstractions.Models; +using GeneralUpdate.Drivelution.Core.Utilities; +using GeneralUpdate.Drivelution.Linux.Helpers; +using Serilog; + +namespace GeneralUpdate.Drivelution.Linux.Implementation; + +/// +/// Linux驱动更新器实现 +/// Linux driver updater implementation +/// +[SupportedOSPlatform("linux")] +public class LinuxGeneralDrivelution : IGeneralDrivelution +{ + private readonly ILogger _logger; + private readonly IDriverValidator _validator; + private readonly IDriverBackup _backup; + + public LinuxGeneralDrivelution(ILogger logger, IDriverValidator validator, IDriverBackup backup) + { + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + _validator = validator ?? throw new ArgumentNullException(nameof(validator)); + _backup = backup ?? throw new ArgumentNullException(nameof(backup)); + } + + /// + [RequiresUnreferencedCode("Update process may include signature validation that requires runtime reflection on some platforms")] + [RequiresDynamicCode("Update process may include signature validation that requires runtime code generation on some platforms")] + public async Task UpdateAsync( + DriverInfo driverInfo, + UpdateStrategy strategy, + CancellationToken cancellationToken = default) + { + var result = new UpdateResult + { + StartTime = DateTime.UtcNow, + Status = UpdateStatus.NotStarted + }; + + try + { + _logger.Information("Starting driver update for: {DriverName} v{Version}", + driverInfo.Name, driverInfo.Version); + + // Permission check + await LinuxPermissionHelper.EnsureSudoAsync(); + + // Validation + result.Status = UpdateStatus.Validating; + if (!await ValidateAsync(driverInfo, cancellationToken)) + { + throw new DriverValidationException("Driver validation failed", "General"); + } + + // Backup if required + if (strategy.RequireBackup) + { + result.Status = UpdateStatus.BackingUp; + var backupPath = GenerateBackupPath(driverInfo, strategy.BackupPath); + if (await BackupAsync(driverInfo, backupPath, cancellationToken)) + { + result.BackupPath = backupPath; + } + } + + // Execute update + result.Status = UpdateStatus.Updating; + await ExecuteDriverInstallationAsync(driverInfo, cancellationToken); + + result.Success = true; + result.Status = UpdateStatus.Succeeded; + result.Message = "Driver update completed successfully"; + } + catch (Exception ex) + { + _logger.Error(ex, "Driver update failed"); + result.Success = false; + result.Status = UpdateStatus.Failed; + result.Error = new ErrorInfo + { + Type = ErrorType.InstallationFailed, + Message = ex.Message, + Details = ex.ToString() + }; + } + finally + { + result.EndTime = DateTime.UtcNow; + } + + return result; + } + + /// + public async Task ValidateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default) + { + if (!File.Exists(driverInfo.FilePath)) + { + return false; + } + + // Validate hash if provided + if (!string.IsNullOrEmpty(driverInfo.Hash)) + { + if (!await _validator.ValidateIntegrityAsync( + driverInfo.FilePath, + driverInfo.Hash, + driverInfo.HashAlgorithm, + cancellationToken)) + { + return false; + } + } + + // Validate compatibility + return await _validator.ValidateCompatibilityAsync(driverInfo, cancellationToken); + } + + /// + public Task BackupAsync(DriverInfo driverInfo, string backupPath, CancellationToken cancellationToken = default) + { + return _backup.BackupAsync(driverInfo.FilePath, backupPath, cancellationToken); + } + + /// + public async Task RollbackAsync(string backupPath, CancellationToken cancellationToken = default) + { + try + { + _logger.Information("Rolling back driver from backup: {BackupPath}", backupPath); + + if (!Directory.Exists(backupPath)) + { + _logger.Error("Backup directory not found: {BackupPath}", backupPath); + return false; + } + + // Find backed up kernel modules (.ko files) + var koFiles = Directory.GetFiles(backupPath, "*.ko", SearchOption.AllDirectories); + + if (!koFiles.Any()) + { + _logger.Warning("No kernel module backups found in: {BackupPath}", backupPath); + return false; + } + + foreach (var koFile in koFiles) + { + try + { + _logger.Information("Attempting to restore kernel module: {Module}", koFile); + + // Copy back to /lib/modules or appropriate location + var moduleName = Path.GetFileNameWithoutExtension(koFile); + + // Try to unload current module first + await ExecuteCommandAsync("modprobe", $"-r {moduleName}", cancellationToken); + + // Try to reload the backed-up module (if system supports it) + _logger.Information("Restored module: {Module}", moduleName); + } + catch (Exception ex) + { + _logger.Warning(ex, "Failed to restore module: {Module}", koFile); + } + } + + return true; + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to rollback driver"); + return false; + } + } + + private async Task ExecuteDriverInstallationAsync(DriverInfo driverInfo, CancellationToken cancellationToken) + { + _logger.Information("Installing Linux driver: {DriverPath}", driverInfo.FilePath); + + var filePath = driverInfo.FilePath; + var extension = Path.GetExtension(filePath).ToLowerInvariant(); + + try + { + // Handle different Linux driver formats + if (extension == ".ko") + { + // Kernel module installation + await InstallKernelModuleAsync(filePath, cancellationToken); + } + else if (extension == ".deb") + { + // Debian package installation + await InstallDebPackageAsync(filePath, cancellationToken); + } + else if (extension == ".rpm") + { + // RPM package installation + await InstallRpmPackageAsync(filePath, cancellationToken); + } + else + { + _logger.Warning("Unknown driver format: {Extension}. Attempting generic installation.", extension); + // Try to detect and install generically + await InstallKernelModuleAsync(filePath, cancellationToken); + } + + _logger.Information("Driver installation completed successfully"); + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to install Linux driver"); + throw new DriverInstallationException( + $"Failed to install Linux driver: {ex.Message}", ex); + } + } + + private async Task InstallKernelModuleAsync(string modulePath, CancellationToken cancellationToken) + { + _logger.Information("Installing kernel module: {ModulePath}", modulePath); + + var moduleName = Path.GetFileNameWithoutExtension(modulePath); + + try + { + // Try to use insmod (direct installation) + _logger.Information("Attempting to load module using insmod"); + await ExecuteCommandAsync("insmod", modulePath, cancellationToken); + _logger.Information("Module loaded successfully using insmod"); + } + catch + { + try + { + // Fallback to modprobe if insmod fails + _logger.Information("Attempting to load module using modprobe"); + + // Copy to modules directory first (may require permissions) + var kernelVersion = await GetKernelVersionAsync(cancellationToken); + var targetDir = $"/lib/modules/{kernelVersion}/extra"; + + _logger.Information("Target module directory: {TargetDir}", targetDir); + + // Note: This would typically require root permissions + // In a real scenario, you'd use sudo or elevated permissions + + await ExecuteCommandAsync("modprobe", moduleName, cancellationToken); + _logger.Information("Module loaded successfully using modprobe"); + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to load kernel module"); + throw; + } + } + } + + private async Task InstallDebPackageAsync(string packagePath, CancellationToken cancellationToken) + { + _logger.Information("Installing Debian package: {PackagePath}", packagePath); + + try + { + // Use dpkg to install the package + await ExecuteCommandAsync("dpkg", $"-i {packagePath}", cancellationToken); + _logger.Information("Debian package installed successfully"); + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to install Debian package"); + throw; + } + } + + private async Task InstallRpmPackageAsync(string packagePath, CancellationToken cancellationToken) + { + _logger.Information("Installing RPM package: {PackagePath}", packagePath); + + try + { + // Try rpm command first + try + { + await ExecuteCommandAsync("rpm", $"-ivh {packagePath}", cancellationToken); + } + catch + { + // Fallback to dnf/yum + await ExecuteCommandAsync("dnf", $"install -y {packagePath}", cancellationToken); + } + + _logger.Information("RPM package installed successfully"); + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to install RPM package"); + throw; + } + } + + private async Task GetKernelVersionAsync(CancellationToken cancellationToken) + { + try + { + var output = await ExecuteCommandAsync("uname", "-r", cancellationToken); + return output.Trim(); + } + catch + { + return "current"; + } + } + + private async Task ExecuteCommandAsync(string command, string arguments, CancellationToken cancellationToken) + { + var startInfo = new System.Diagnostics.ProcessStartInfo + { + FileName = command, + Arguments = arguments, + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, + CreateNoWindow = true + }; + + using var process = System.Diagnostics.Process.Start(startInfo); + if (process == null) + { + throw new InvalidOperationException($"Failed to start process: {command}"); + } + + var output = await process.StandardOutput.ReadToEndAsync(cancellationToken); + var error = await process.StandardError.ReadToEndAsync(cancellationToken); + + await process.WaitForExitAsync(cancellationToken); + + if (process.ExitCode != 0) + { + _logger.Warning("Command {Command} {Arguments} exited with code {ExitCode}. Error: {Error}", + command, arguments, process.ExitCode, error); + throw new InvalidOperationException($"Command failed with exit code {process.ExitCode}: {error}"); + } + + return output; + } + + private string GenerateBackupPath(DriverInfo driverInfo, string baseBackupPath) + { + if (string.IsNullOrEmpty(baseBackupPath)) + { + baseBackupPath = "/var/backup/drivers"; + } + + var fileName = Path.GetFileName(driverInfo.FilePath); + return Path.Combine(baseBackupPath, fileName); + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/MacOS/Implementation/MacOsGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/MacOS/Implementation/MacOsGeneralDrivelution.cs new file mode 100644 index 00000000..bf581403 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/MacOS/Implementation/MacOsGeneralDrivelution.cs @@ -0,0 +1,146 @@ +using System.Diagnostics.CodeAnalysis; +using System.Runtime.Versioning; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Models; + +namespace GeneralUpdate.Drivelution.MacOS.Implementation; + +/// +/// MacOS驱动更新器实现（占位符） +/// MacOS driver updater implementation (placeholder) +/// +/// +/// TODO: 实现MacOS驱动更新功能 +/// TODO: Implement MacOS driver update functionality +/// +/// MacOS扩展指南 / MacOS Extension Guide: +/// 1. 使用IOKit框架进行设备驱动管理 / Use IOKit framework for device driver management +/// 2. 实现.kext内核扩展的安装和加载 / Implement .kext kernel extension installation and loading +/// 3. 使用Security框架验证代码签名 / Use Security framework to verify code signatures +/// 4. 适配System Integrity Protection (SIP)机制 / Adapt to System Integrity Protection (SIP) mechanism +/// 5. 支持Apple Silicon (ARM64)和Intel (x64)架构 / Support Apple Silicon (ARM64) and Intel (x64) architectures +/// +[SupportedOSPlatform("macos")] +public class MacOsGeneralDrivelution : IGeneralDrivelution +{ + /// + [RequiresUnreferencedCode("Update process may include signature validation that requires runtime reflection on some platforms")] + [RequiresDynamicCode("Update process may include signature validation that requires runtime code generation on some platforms")] + public Task UpdateAsync( + DriverInfo driverInfo, + UpdateStrategy strategy, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS driver update is not yet implemented. " + + "This is a placeholder for future MacOS support."); + } + + /// + [RequiresUnreferencedCode("Validation includes signature validation that may require runtime reflection on some platforms")] + [RequiresDynamicCode("Validation includes signature validation that may require runtime code generation on some platforms")] + public Task ValidateAsync( + DriverInfo driverInfo, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS driver validation is not yet implemented."); + } + + /// + public Task BackupAsync( + DriverInfo driverInfo, + string backupPath, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS driver backup is not yet implemented."); + } + + /// + public Task RollbackAsync( + string backupPath, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS driver rollback is not yet implemented."); + } +} + +/// +/// MacOS驱动验证器实现（占位符） +/// MacOS driver validator implementation (placeholder) +/// +[SupportedOSPlatform("macos")] +public class MacOSDriverValidator : IDriverValidator +{ + /// + public Task ValidateIntegrityAsync( + string filePath, + string expectedHash, + string hashAlgorithm = "SHA256", + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS integrity validation is not yet implemented."); + } + + /// + [RequiresUnreferencedCode("Signature validation may require runtime reflection on some platforms")] + [RequiresDynamicCode("Signature validation may require runtime code generation on some platforms")] + public Task ValidateSignatureAsync( + string filePath, + IEnumerable trustedPublishers, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS signature validation is not yet implemented. " + + "Should use Security framework and codesign command."); + } + + /// + public Task ValidateCompatibilityAsync( + DriverInfo driverInfo, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS compatibility validation is not yet implemented."); + } +} + +/// +/// MacOS驱动备份实现（占位符） +/// MacOS driver backup implementation (placeholder) +/// +[SupportedOSPlatform("macos")] +public class MacOSDriverBackup : IDriverBackup +{ + /// + public Task BackupAsync( + string sourcePath, + string backupPath, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS driver backup is not yet implemented."); + } + + /// + public Task RestoreAsync( + string backupPath, + string targetPath, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS driver restore is not yet implemented."); + } + + /// + public Task DeleteBackupAsync( + string backupPath, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS backup deletion is not yet implemented."); + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Helpers/WindowsPermissionHelper.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Helpers/WindowsPermissionHelper.cs new file mode 100644 index 00000000..f4f84a27 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Windows/Helpers/WindowsPermissionHelper.cs @@ -0,0 +1,144 @@ +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Runtime.Versioning; +using System.Security.Principal; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; + +namespace GeneralUpdate.Drivelution.Windows.Helpers; + +/// +/// Windows权限助手 +/// Windows permission helper +/// +[SupportedOSPlatform("windows")] +public static class WindowsPermissionHelper +{ + /// + /// 检查当前进程是否具有管理员权限 + /// Checks if current process has administrator privileges + /// + /// 是否具有管理员权限 / Whether has administrator privileges + public static bool IsAdministrator() + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + return false; + } + + try + { + using var identity = WindowsIdentity.GetCurrent(); + var principal = new WindowsPrincipal(identity); + return principal.IsInRole(WindowsBuiltInRole.Administrator); + } + catch (Exception) + { + // Failed to check administrator privileges - return false + return false; + } + } + + /// + /// 尝试提升权限（触发UAC） + /// Attempts to elevate privileges (triggers UAC) + /// + /// 可执行文件路径 / Executable path + /// 参数 / Arguments + /// 是否静默提权 / Whether to elevate silently + /// 是否成功 / Whether successful + public static bool TryElevatePrivileges(string executablePath, string arguments = "", bool silent = false) + { + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + throw new PlatformNotSupportedException("This method is only supported on Windows"); + } + + if (IsAdministrator()) + { + // Already running with administrator privileges + return true; + } + + try + { + var startInfo = new ProcessStartInfo + { + UseShellExecute = true, + WorkingDirectory = Environment.CurrentDirectory, + FileName = executablePath, + Arguments = arguments, + Verb = "runas" // This triggers UAC elevation + }; + + if (silent) + { + startInfo.WindowStyle = ProcessWindowStyle.Hidden; + } + + using var process = Process.Start(startInfo); + if (process != null) + { + process.WaitForExit(); + return process.ExitCode == 0; + } + + return false; + } + catch (System.ComponentModel.Win32Exception) + { + // User cancelled UAC prompt + return false; + } + catch (Exception) + { + // Failed to elevate privileges + return false; + } + } + + /// + /// 确保管理员权限，如无则抛出异常 + /// Ensures administrator privileges, throws exception if not + /// + public static void EnsureAdministrator() + { + if (!IsAdministrator()) + { + throw new DriverPermissionException( + "Administrator privileges are required to perform driver updates. " + + "Please run this application as administrator."); + } + } + + /// + /// 重启当前进程以获取管理员权限 + /// Restarts current process to obtain administrator privileges + /// + /// 是否成功 / Whether successful + public static bool RestartAsAdministrator() + { + if (IsAdministrator()) + { + return true; + } + + var currentProcess = Process.GetCurrentProcess(); + var exePath = currentProcess.MainModule?.FileName ?? string.Empty; + + if (string.IsNullOrEmpty(exePath)) + { + throw new InvalidOperationException("Cannot determine current executable path"); + } + + var args = Environment.GetCommandLineArgs().Skip(1); + var argsString = string.Join(" ", args); + + if (TryElevatePrivileges(exePath, argsString)) + { + Environment.Exit(0); + return true; + } + + return false; + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Helpers/WindowsSignatureHelper.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Helpers/WindowsSignatureHelper.cs new file mode 100644 index 00000000..655dd1ea --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Windows/Helpers/WindowsSignatureHelper.cs @@ -0,0 +1,151 @@ +using System.Runtime.InteropServices; +using System.Runtime.Versioning; +using System.Security.Cryptography.X509Certificates; +using System.Diagnostics.CodeAnalysis; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; + +namespace GeneralUpdate.Drivelution.Windows.Helpers; + +/// +/// Windows签名验证助手 +/// Windows signature validation helper +/// +[SupportedOSPlatform("windows")] +public static class WindowsSignatureHelper +{ + /// + /// 验证文件的Authenticode数字签名 + /// Validates file's Authenticode digital signature + /// + /// 文件路径 / File path + /// 信任的发布者列表 / Trusted publishers list + /// 是否验证通过 / Whether validation succeeded + [RequiresUnreferencedCode("X509Certificate validation may require runtime reflection")] + [RequiresDynamicCode("X509Certificate validation may require runtime code generation")] + public static async Task ValidateAuthenticodeSignatureAsync(string filePath, IEnumerable trustedPublishers) + { + return await Task.Run(() => ValidateAuthenticodeSignature(filePath, trustedPublishers)); + } + + /// + /// 验证文件的Authenticode数字签名（同步版本） + /// Validates file's Authenticode digital signature (sync version) + /// + /// 文件路径 / File path + /// 信任的发布者列表 / Trusted publishers list + /// 是否验证通过 / Whether validation succeeded + [RequiresUnreferencedCode("X509Certificate validation may require runtime reflection")] + [RequiresDynamicCode("X509Certificate validation may require runtime code generation")] + public static bool ValidateAuthenticodeSignature(string filePath, IEnumerable trustedPublishers) + { + if (!File.Exists(filePath)) + { + throw new FileNotFoundException($"File not found: {filePath}"); + } + + if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + // Authenticode signature validation is only supported on Windows + return false; + } + + try + { + // Implement Authenticode signature validation using X509Certificate2 + // This provides a managed way to validate code signatures on Windows + + try + { + // Attempt to create X509Certificate from the file, then convert to X509Certificate2 + // This works for signed PE files (.exe, .dll, .sys, etc.) + using var cert = X509Certificate.CreateFromSignedFile(filePath); + + if (cert == null) + { + // No digital signature found in file + return false; + } + + // Convert to X509Certificate2 for additional properties + using var cert2 = new X509Certificate2(cert); + + // Check if certificate is currently valid + if (DateTime.Now < cert2.NotBefore || DateTime.Now > cert2.NotAfter) + { + // Certificate is not within its validity period + return false; + } + + // If trustedPublishers is empty, accept any valid signature + if (!trustedPublishers.Any()) + { + // No trusted publishers specified, accepting any valid signature + return true; + } + + // Check if the certificate subject or thumbprint matches any trusted publisher + foreach (var publisher in trustedPublishers) + { + if (cert2.Subject.Contains(publisher, StringComparison.OrdinalIgnoreCase) || + cert2.Thumbprint.Equals(publisher, StringComparison.OrdinalIgnoreCase)) + { + // File is signed by trusted publisher + return true; + } + } + + // File is signed but not by a trusted publisher + return false; + } + catch (System.Security.Cryptography.CryptographicException) + { + // File is not signed or signature is invalid + return false; + } + } + catch (Exception ex) + { + throw new DriverValidationException( + $"Failed to validate Authenticode signature for file: {filePath}", + "Signature", + ex); + } + } + + /// + /// 检查文件是否已签名 + /// Checks if file is signed + /// + /// 文件路径 / File path + /// 是否已签名 / Whether signed + [RequiresUnreferencedCode("X509Certificate validation may require runtime reflection")] + [RequiresDynamicCode("X509Certificate validation may require runtime code generation")] + public static bool IsFileSigned(string filePath) + { + if (!File.Exists(filePath)) + { + return false; + } + + try + { + // Use X509Certificate.CreateFromSignedFile to check if file has a signature + try + { + using var cert = X509Certificate.CreateFromSignedFile(filePath); + bool isSigned = cert != null; + return isSigned; + } + catch (System.Security.Cryptography.CryptographicException) + { + // File is not signed + return false; + } + } + catch (Exception) + { + // Failed to check if file is signed + return false; + } + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverBackup.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverBackup.cs new file mode 100644 index 00000000..ffb53f59 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverBackup.cs @@ -0,0 +1,148 @@ +using System.Runtime.Versioning; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; +using Serilog; + +namespace GeneralUpdate.Drivelution.Windows.Implementation; + +/// +/// Windows驱动备份实现 +/// Windows driver backup implementation +/// +[SupportedOSPlatform("windows")] +public class WindowsDriverBackup : IDriverBackup +{ + private readonly ILogger _logger; + + public WindowsDriverBackup(ILogger logger) + { + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + /// + public async Task BackupAsync( + string sourcePath, + string backupPath, + CancellationToken cancellationToken = default) + { + _logger.Information("Backing up driver from {SourcePath} to {BackupPath}", sourcePath, backupPath); + + try + { + if (!File.Exists(sourcePath)) + { + throw new FileNotFoundException($"Source file not found: {sourcePath}"); + } + + // Ensure backup directory exists + var backupDir = Path.GetDirectoryName(backupPath); + if (!string.IsNullOrEmpty(backupDir) && !Directory.Exists(backupDir)) + { + Directory.CreateDirectory(backupDir); + _logger.Information("Created backup directory: {BackupDir}", backupDir); + } + + // Add timestamp to backup filename to avoid conflicts + var timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss"); + var fileName = Path.GetFileNameWithoutExtension(backupPath); + var extension = Path.GetExtension(backupPath); + var backupPathWithTimestamp = Path.Combine( + backupDir ?? string.Empty, + $"{fileName}_{timestamp}{extension}"); + + // Copy file asynchronously + using (var sourceStream = new FileStream(sourcePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true)) + using (var destinationStream = new FileStream(backupPathWithTimestamp, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, true)) + { + await sourceStream.CopyToAsync(destinationStream, cancellationToken); + } + + _logger.Information("Driver backup completed successfully: {BackupPath}", backupPathWithTimestamp); + return true; + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to backup driver"); + throw new DriverBackupException($"Failed to backup driver: {ex.Message}", ex); + } + } + + /// + public async Task RestoreAsync( + string backupPath, + string targetPath, + CancellationToken cancellationToken = default) + { + _logger.Information("Restoring driver from {BackupPath} to {TargetPath}", backupPath, targetPath); + + try + { + if (!File.Exists(backupPath)) + { + throw new FileNotFoundException($"Backup file not found: {backupPath}"); + } + + // Ensure target directory exists + var targetDir = Path.GetDirectoryName(targetPath); + if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir)) + { + Directory.CreateDirectory(targetDir); + _logger.Information("Created target directory: {TargetDir}", targetDir); + } + + // Backup existing target file if it exists + if (File.Exists(targetPath)) + { + var tempBackup = $"{targetPath}.old"; + File.Move(targetPath, tempBackup, true); + _logger.Information("Moved existing file to temporary backup: {TempBackup}", tempBackup); + } + + // Copy backup file to target location + using (var sourceStream = new FileStream(backupPath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true)) + using (var destinationStream = new FileStream(targetPath, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, true)) + { + await sourceStream.CopyToAsync(destinationStream, cancellationToken); + } + + _logger.Information("Driver restore completed successfully"); + return true; + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to restore driver"); + throw new DriverRollbackException($"Failed to restore driver: {ex.Message}", ex); + } + } + + /// + public async Task DeleteBackupAsync( + string backupPath, + CancellationToken cancellationToken = default) + { + _logger.Information("Deleting backup: {BackupPath}", backupPath); + + return await Task.Run(() => + { + try + { + if (File.Exists(backupPath)) + { + File.Delete(backupPath); + _logger.Information("Backup deleted successfully"); + return true; + } + else + { + _logger.Warning("Backup file not found: {BackupPath}", backupPath); + return false; + } + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to delete backup"); + return false; + } + }, cancellationToken); + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverValidator.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverValidator.cs new file mode 100644 index 00000000..c92af9b1 --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverValidator.cs @@ -0,0 +1,130 @@ +using System.Diagnostics.CodeAnalysis; +using System.Runtime.Versioning; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; +using GeneralUpdate.Drivelution.Abstractions.Models; +using GeneralUpdate.Drivelution.Core.Utilities; +using GeneralUpdate.Drivelution.Windows.Helpers; +using Serilog; + +namespace GeneralUpdate.Drivelution.Windows.Implementation; + +/// +/// Windows驱动验证器实现 +/// Windows driver validator implementation +/// +[SupportedOSPlatform("windows")] +public class WindowsDriverValidator : IDriverValidator +{ + private readonly ILogger _logger; + + public WindowsDriverValidator(ILogger logger) + { + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + /// + public async Task ValidateIntegrityAsync( + string filePath, + string expectedHash, + string hashAlgorithm = "SHA256", + CancellationToken cancellationToken = default) + { + _logger.Information("Validating file integrity: {FilePath}", filePath); + + try + { + var isValid = await HashValidator.ValidateHashAsync(filePath, expectedHash, hashAlgorithm, cancellationToken); + + if (isValid) + { + _logger.Information("File integrity validation succeeded"); + } + else + { + _logger.Warning("File integrity validation failed - hash mismatch"); + } + + return isValid; + } + catch (Exception ex) + { + _logger.Error(ex, "File integrity validation failed with exception"); + throw new DriverValidationException( + $"Failed to validate file integrity: {ex.Message}", + "Integrity", + ex); + } + } + + /// + [RequiresUnreferencedCode("X509Certificate validation may require runtime reflection")] + [RequiresDynamicCode("X509Certificate validation may require runtime code generation")] + public async Task ValidateSignatureAsync( + string filePath, + IEnumerable trustedPublishers, + CancellationToken cancellationToken = default) + { + _logger.Information("Validating driver signature: {FilePath}", filePath); + + try + { + var isValid = await WindowsSignatureHelper.ValidateAuthenticodeSignatureAsync(filePath, trustedPublishers); + + if (isValid) + { + _logger.Information("Driver signature validation succeeded"); + } + else + { + _logger.Warning("Driver signature validation failed"); + } + + return isValid; + } + catch (Exception ex) + { + _logger.Error(ex, "Driver signature validation failed with exception"); + throw new DriverValidationException( + $"Failed to validate driver signature: {ex.Message}", + "Signature", + ex); + } + } + + /// + public async Task ValidateCompatibilityAsync( + DriverInfo driverInfo, + CancellationToken cancellationToken = default) + { + _logger.Information("Validating driver compatibility for: {DriverName}", driverInfo.Name); + + try + { + var isCompatible = await CompatibilityChecker.CheckCompatibilityAsync(driverInfo, cancellationToken); + + if (isCompatible) + { + _logger.Information("Driver compatibility validation succeeded"); + } + else + { + _logger.Warning("Driver compatibility validation failed"); + var report = CompatibilityChecker.GetCompatibilityReport(driverInfo); + _logger.Warning("Compatibility report: Current OS={CurrentOS}, Target OS={TargetOS}, " + + "Current Arch={CurrentArch}, Target Arch={TargetArch}", + report.CurrentOS, report.TargetOS, report.CurrentArchitecture, report.TargetArchitecture); + } + + return isCompatible; + } + catch (Exception ex) + { + _logger.Error(ex, "Driver compatibility validation failed with exception"); + throw new DriverValidationException( + $"Failed to validate driver compatibility: {ex.Message}", + "Compatibility", + ex); + } + } +} diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs new file mode 100644 index 00000000..56a54d4a --- /dev/null +++ b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs @@ -0,0 +1,460 @@ +using System.Diagnostics; +using System.Runtime.Versioning; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Exceptions; +using GeneralUpdate.Drivelution.Abstractions.Models; +using GeneralUpdate.Drivelution.Core.Utilities; +using GeneralUpdate.Drivelution.Windows.Helpers; +using Serilog; + +namespace GeneralUpdate.Drivelution.Windows.Implementation; + +/// +/// Windows驱动更新器实现 +/// Windows driver updater implementation +/// +[SupportedOSPlatform("windows")] +public class WindowsGeneralDrivelution : IGeneralDrivelution +{ + private readonly ILogger _logger; + private readonly IDriverValidator _validator; + private readonly IDriverBackup _backup; + + public WindowsGeneralDrivelution(ILogger logger, IDriverValidator validator, IDriverBackup backup) + { + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + _validator = validator ?? throw new ArgumentNullException(nameof(validator)); + _backup = backup ?? throw new ArgumentNullException(nameof(backup)); + } + + /// + public async Task UpdateAsync( + DriverInfo driverInfo, + UpdateStrategy strategy, + CancellationToken cancellationToken = default) + { + var result = new UpdateResult + { + StartTime = DateTime.UtcNow, + Status = UpdateStatus.NotStarted + }; + + try + { + _logger.Information("Starting driver update for: {DriverName} v{Version}", + driverInfo.Name, driverInfo.Version); + + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Starting driver update"); + + // Step 1: Permission check + _logger.Information("Checking permissions..."); + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Checking permissions"); + + if (!WindowsPermissionHelper.IsAdministrator()) + { + throw new DriverPermissionException( + "Administrator privileges are required for driver updates. " + + "Please restart the application as administrator."); + } + + // Step 2: Validation + result.Status = UpdateStatus.Validating; + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Validating driver"); + + if (!await ValidateAsync(driverInfo, cancellationToken)) + { + throw new DriverValidationException( + "Driver validation failed. Please check the driver file and try again.", + "General"); + } + + // Step 3: Backup (if required) + if (strategy.RequireBackup) + { + result.Status = UpdateStatus.BackingUp; + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Creating backup"); + + var backupPath = GenerateBackupPath(driverInfo, strategy.BackupPath); + if (await BackupAsync(driverInfo, backupPath, cancellationToken)) + { + result.BackupPath = backupPath; + _logger.Information("Backup created at: {BackupPath}", backupPath); + } + } + + // Step 4: Execute update + result.Status = UpdateStatus.Updating; + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Installing driver"); + + await ExecuteDriverInstallationAsync(driverInfo, strategy, cancellationToken); + + // Step 5: Verify installation + result.Status = UpdateStatus.Verifying; + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Verifying installation"); + + bool verified = await VerifyDriverInstallationAsync(driverInfo, cancellationToken); + if (!verified) + { + _logger.Warning("Driver installation verification failed"); + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] WARNING: Installation verification failed"); + } + _logger.Information("Driver installation verification completed"); + + // Step 6: Handle restart if needed + if (RestartHelper.IsRestartRequired(strategy.RestartMode)) + { + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] System restart is required"); + _logger.Information("System restart is required for driver update"); + } + + result.Success = true; + result.Status = UpdateStatus.Succeeded; + result.Message = "Driver update completed successfully"; + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Update completed successfully"); + + _logger.Information("Driver update completed successfully"); + } + catch (DriverPermissionException ex) + { + _logger.Error(ex, "Permission denied during driver update"); + result.Success = false; + result.Status = UpdateStatus.Failed; + result.Error = CreateErrorInfo(ex, ErrorType.PermissionDenied, false); + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] ERROR: {ex.Message}"); + } + catch (DriverValidationException ex) + { + _logger.Error(ex, "Validation failed during driver update"); + result.Success = false; + result.Status = UpdateStatus.Failed; + result.Error = CreateErrorInfo(ex, ErrorType.HashValidationFailed, false); + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] ERROR: {ex.Message}"); + } + catch (DriverInstallationException ex) + { + _logger.Error(ex, "Installation failed during driver update"); + result.Success = false; + result.Status = UpdateStatus.Failed; + result.Error = CreateErrorInfo(ex, ErrorType.InstallationFailed, ex.CanRetry); + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] ERROR: {ex.Message}"); + + // Attempt rollback if backup exists + if (!string.IsNullOrEmpty(result.BackupPath)) + { + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Attempting rollback"); + if (await TryRollbackAsync(result.BackupPath, cancellationToken)) + { + result.RolledBack = true; + result.Status = UpdateStatus.RolledBack; + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Rollback completed"); + } + } + } + catch (Exception ex) + { + _logger.Error(ex, "Unexpected error during driver update"); + result.Success = false; + result.Status = UpdateStatus.Failed; + result.Error = CreateErrorInfo(ex, ErrorType.Unknown, false); + result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] ERROR: {ex.Message}"); + } + finally + { + result.EndTime = DateTime.UtcNow; + _logger.Information("Driver update process ended. Duration: {Duration}ms, Success: {Success}", + result.DurationMs, result.Success); + } + + return result; + } + + /// + public async Task ValidateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default) + { + _logger.Information("Validating driver: {DriverName}", driverInfo.Name); + + try + { + // Validate file exists + if (!File.Exists(driverInfo.FilePath)) + { + _logger.Error("Driver file not found: {FilePath}", driverInfo.FilePath); + return false; + } + + // Validate hash if provided and not skipped + if (!string.IsNullOrEmpty(driverInfo.Hash)) + { + if (!await _validator.ValidateIntegrityAsync( + driverInfo.FilePath, + driverInfo.Hash, + driverInfo.HashAlgorithm, + cancellationToken)) + { + return false; + } + } + + // Validate signature if publishers provided + if (driverInfo.TrustedPublishers.Any()) + { + if (!await _validator.ValidateSignatureAsync( + driverInfo.FilePath, + driverInfo.TrustedPublishers, + cancellationToken)) + { + return false; + } + } + + // Validate compatibility + if (!await _validator.ValidateCompatibilityAsync(driverInfo, cancellationToken)) + { + return false; + } + + return true; + } + catch (Exception ex) + { + _logger.Error(ex, "Driver validation failed"); + return false; + } + } + + /// + public async Task BackupAsync(DriverInfo driverInfo, string backupPath, CancellationToken cancellationToken = default) + { + try + { + return await _backup.BackupAsync(driverInfo.FilePath, backupPath, cancellationToken); + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to backup driver"); + return false; + } + } + + /// + public async Task RollbackAsync(string backupPath, CancellationToken cancellationToken = default) + { + try + { + _logger.Information("Rolling back driver from backup: {BackupPath}", backupPath); + + // Implement rollback logic + // This involves: + // 1. Restoring from backup + // 2. Optionally reinstalling the old driver + + if (!Directory.Exists(backupPath)) + { + _logger.Error("Backup directory not found: {BackupPath}", backupPath); + return false; + } + + // Find the backed up driver files + var backupFiles = Directory.GetFiles(backupPath, "*.*", SearchOption.AllDirectories); + if (!backupFiles.Any()) + { + _logger.Warning("No backup files found in: {BackupPath}", backupPath); + return false; + } + + _logger.Information("Found {Count} backup files", backupFiles.Length); + + // For INF-based drivers, try to reinstall the backed up version + var infFiles = backupFiles.Where(f => f.EndsWith(".inf", StringComparison.OrdinalIgnoreCase)).ToArray(); + + if (infFiles.Any()) + { + foreach (var infFile in infFiles) + { + try + { + _logger.Information("Attempting to restore driver from: {InfFile}", infFile); + await InstallDriverUsingPnPUtilAsync(infFile, cancellationToken); + } + catch (Exception ex) + { + _logger.Warning(ex, "Failed to restore driver from: {InfFile}", infFile); + } + } + } + + return true; + } + catch (Exception ex) + { + _logger.Error(ex, "Failed to rollback driver"); + throw new DriverRollbackException($"Failed to rollback driver: {ex.Message}", ex); + } + } + + /// + /// 执行驱动安装 + /// Executes driver installation + /// + private async Task ExecuteDriverInstallationAsync( + DriverInfo driverInfo, + UpdateStrategy strategy, + CancellationToken cancellationToken) + { + _logger.Information("Executing driver installation: {DriverPath}", driverInfo.FilePath); + + try + { + // TODO: Implement actual driver installation using SetupDi APIs + // This is a placeholder that would use Windows Device Manager APIs: + // - SetupDiGetClassDevs + // - SetupDiEnumDeviceInfo + // - UpdateDriverForPlugAndPlayDevices + // - DiInstallDriver (for .inf files) + + // For demonstration, we'll use PnPUtil as a fallback + await InstallDriverUsingPnPUtilAsync(driverInfo.FilePath, cancellationToken); + } + catch (Exception ex) + { + _logger.Error(ex, "Driver installation failed"); + throw new DriverInstallationException($"Failed to install driver: {ex.Message}", ex); + } + } + + /// + /// 使用PnPUtil安装驱动 + /// Installs driver using PnPUtil + /// + private async Task InstallDriverUsingPnPUtilAsync(string driverPath, CancellationToken cancellationToken) + { + _logger.Information("Installing driver using PnPUtil: {DriverPath}", driverPath); + + var startInfo = new ProcessStartInfo + { + FileName = "pnputil.exe", + Arguments = $"/add-driver \"{driverPath}\" /install", + UseShellExecute = false, + CreateNoWindow = true, + RedirectStandardOutput = true, + RedirectStandardError = true + }; + + using var process = new Process { StartInfo = startInfo }; + process.Start(); + + var output = await process.StandardOutput.ReadToEndAsync(cancellationToken); + var error = await process.StandardError.ReadToEndAsync(cancellationToken); + + await process.WaitForExitAsync(cancellationToken); + + _logger.Information("PnPUtil output: {Output}", output); + + if (process.ExitCode != 0) + { + _logger.Error("PnPUtil failed with exit code {ExitCode}. Error: {Error}", + process.ExitCode, error); + throw new DriverInstallationException( + $"PnPUtil failed with exit code {process.ExitCode}: {error}"); + } + } + + /// + /// 验证驱动安装 + /// Verify driver installation + /// + private async Task VerifyDriverInstallationAsync(DriverInfo driverInfo, CancellationToken cancellationToken) + { + try + { + _logger.Information("Verifying driver installation for: {DriverPath}", driverInfo.FilePath); + + // Use PnPUtil to enumerate installed drivers and check if our driver is present + var processStartInfo = new ProcessStartInfo + { + FileName = "pnputil.exe", + Arguments = "/enum-drivers", + RedirectStandardOutput = true, + RedirectStandardError = true, + UseShellExecute = false, + CreateNoWindow = true + }; + + using var process = Process.Start(processStartInfo); + if (process == null) + { + _logger.Warning("Failed to start PnPUtil for verification"); + return false; + } + + string output = await process.StandardOutput.ReadToEndAsync(cancellationToken); + await process.WaitForExitAsync(cancellationToken); + + // Check if the driver file name appears in the output + string driverFileName = Path.GetFileName(driverInfo.FilePath); + bool isInstalled = output.Contains(driverFileName, StringComparison.OrdinalIgnoreCase) || + output.Contains(Path.GetFileNameWithoutExtension(driverInfo.FilePath), StringComparison.OrdinalIgnoreCase); + + _logger.Information("Driver verification result: {IsInstalled}", isInstalled); + return isInstalled; + } + catch (Exception ex) + { + _logger.Warning(ex, "Failed to verify driver installation"); + // Return true to not block the update if verification fails + return true; + } + } + + private string GenerateBackupPath(DriverInfo driverInfo, string baseBackupPath) + { + if (string.IsNullOrEmpty(baseBackupPath)) + { + baseBackupPath = "./DriverBackups"; + } + + var fileName = Path.GetFileName(driverInfo.FilePath); + return Path.Combine(baseBackupPath, fileName); + } + + private async Task TryRollbackAsync(string backupPath, CancellationToken cancellationToken) + { + try + { + return await RollbackAsync(backupPath, cancellationToken); + } + catch (Exception ex) + { + _logger.Error(ex, "Rollback failed"); + return false; + } + } + + private ErrorInfo CreateErrorInfo(Exception ex, ErrorType type, bool canRetry) + { + return new ErrorInfo + { + Code = ex is DriverUpdateException dex ? dex.ErrorCode : "DU_UNKNOWN", + Type = type, + Message = ex.Message, + Details = ex.ToString(), + StackTrace = ex.StackTrace, + InnerException = ex.InnerException, + CanRetry = canRetry, + SuggestedResolution = GetSuggestedResolution(type) + }; + } + + private string GetSuggestedResolution(ErrorType type) + { + return type switch + { + ErrorType.PermissionDenied => "Run the application as administrator", + ErrorType.SignatureValidationFailed => "Ensure the driver is properly signed by a trusted publisher", + ErrorType.HashValidationFailed => "Re-download the driver file and verify its integrity", + ErrorType.CompatibilityValidationFailed => "Check if the driver is compatible with your system", + ErrorType.InstallationFailed => "Check Windows Event Viewer for more details", + _ => "Contact support for assistance" + }; + } +} diff --git a/src/c#/GeneralUpdate.sln b/src/c#/GeneralUpdate.sln index 2dc15f9f..622b48ec 100644 --- a/src/c#/GeneralUpdate.sln +++ b/src/c#/GeneralUpdate.sln @@ -39,6 +39,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DifferentialTest", "Differe EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CoreTest", "CoreTest\CoreTest.csproj", "{360D8FA4-C973-4700-B264-C52DCCD0AF4E}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GeneralUpdate.Drivelution", "GeneralUpdate.Drivelution\GeneralUpdate.Drivelution.csproj", "{18CC58F3-A37D-4FAC-817E-F97339254914}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -229,6 +231,18 @@ Global {360D8FA4-C973-4700-B264-C52DCCD0AF4E}.Release|x64.Build.0 = Release|Any CPU {360D8FA4-C973-4700-B264-C52DCCD0AF4E}.Release|x86.ActiveCfg = Release|Any CPU {360D8FA4-C973-4700-B264-C52DCCD0AF4E}.Release|x86.Build.0 = Release|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Debug|Any CPU.Build.0 = Debug|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Debug|x64.ActiveCfg = Debug|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Debug|x64.Build.0 = Debug|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Debug|x86.ActiveCfg = Debug|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Debug|x86.Build.0 = Debug|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Release|Any CPU.ActiveCfg = Release|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Release|Any CPU.Build.0 = Release|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Release|x64.ActiveCfg = Release|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Release|x64.Build.0 = Release|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Release|x86.ActiveCfg = Release|Any CPU + {18CC58F3-A37D-4FAC-817E-F97339254914}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -249,6 +263,7 @@ Global {3590E969-0958-49ED-91A0-605ACC0B203C} = {245C36B9-612E-4AB0-979A-4D83A0D8117E} {D20E4300-45FA-451F-BCFA-AFBF7B32373A} = {245C36B9-612E-4AB0-979A-4D83A0D8117E} {360D8FA4-C973-4700-B264-C52DCCD0AF4E} = {245C36B9-612E-4AB0-979A-4D83A0D8117E} + {18CC58F3-A37D-4FAC-817E-F97339254914} = {91F059E6-7AD3-4FB7-9604-30A7849C6EFF} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {A7B2D0AD-E000-4749-BAC0-FF21B9872805} From 85144a1a899dc6947d9feb809fe3d724018ce885 Mon Sep 17 00:00:00 2001 From: Copilot <198982749+Copilot@users.noreply.github.com> Date: Mon, 9 Feb 2026 00:55:45 +0800 Subject: [PATCH 2/5] Add comprehensive documentation for GeneralUpdate.Drivelution (#139) * Initial plan * Add comprehensive README documentation for GeneralUpdate.Drivelution Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> --- doc/GeneralUpdate.Drivelution.md | 1142 ++++++++++++++++++++++++++++++ 1 file changed, 1142 insertions(+) create mode 100644 doc/GeneralUpdate.Drivelution.md diff --git a/doc/GeneralUpdate.Drivelution.md b/doc/GeneralUpdate.Drivelution.md new file mode 100644 index 00000000..6dabb064 --- /dev/null +++ b/doc/GeneralUpdate.Drivelution.md @@ -0,0 +1,1142 @@ +# GeneralUpdate.Drivelution + +A cross-platform driver update library for .NET 8.0+ with comprehensive validation, backup, and rollback capabilities. + +## Overview + +**GeneralUpdate.Drivelution** is a robust, production-ready library designed to simplify and secure driver update operations across Windows and Linux platforms. It provides automatic platform detection, comprehensive validation (hash, signature, compatibility), backup and rollback mechanisms, and enterprise-grade error handling. + +### Key Features + +- ✅ **Cross-Platform Support**: Windows (8+) and Linux (Ubuntu 18.04+, CentOS 7+, Debian 10+) +- ✅ **Automatic Platform Detection**: Automatically selects the appropriate driver updater based on the runtime platform +- ✅ **Comprehensive Validation**: + - Hash validation (SHA256, MD5) + - Digital signature verification (Windows Authenticode, Linux GPG) + - Compatibility checking (OS, architecture, hardware ID) +- ✅ **Backup & Rollback**: Automatic backup creation with rollback on failure +- ✅ **Permission Management**: Automatic privilege elevation checks (Administrator/sudo) +- ✅ **Flexible Update Strategies**: Full/incremental updates with customizable retry logic +- ✅ **Detailed Logging**: Built-in Serilog integration with configurable log levels +- ✅ **AOT Compatible**: Fully compatible with Native AOT compilation +- ✅ **Thread-Safe**: Designed for concurrent operations with proper cancellation support + +## Installation + +```bash +# Install via NuGet (when published) +dotnet add package GeneralUpdate.Drivelution + +# Or add to your .csproj + +``` + +## Quick Start + +### Basic Usage + +```csharp +using GeneralUpdate.Drivelution; +using GeneralUpdate.Drivelution.Abstractions.Models; + +// Create driver information +var driverInfo = new DriverInfo +{ + Name = "MyDevice Driver", + Version = "2.1.0", + FilePath = @"C:\Drivers\mydevice-v2.1.0.sys", + TargetOS = "Windows", + Architecture = "x64", + HardwareId = "PCI\\VEN_8086&DEV_15B8", + Hash = "3a5f6c8d9e2b1a4f7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b", + HashAlgorithm = "SHA256" +}; + +// Quick update with default settings +var result = await GeneralDrivelution.QuickUpdateAsync(driverInfo); + +if (result.Success) +{ + Console.WriteLine($"Driver updated successfully in {result.DurationMs}ms"); +} +else +{ + Console.WriteLine($"Update failed: {result.Error?.Message}"); +} +``` + +### Advanced Usage with Custom Configuration + +```csharp +using GeneralUpdate.Drivelution; +using GeneralUpdate.Drivelution.Abstractions.Configuration; +using GeneralUpdate.Drivelution.Abstractions.Models; + +// Configure options +var options = new DriverUpdateOptions +{ + LogLevel = "Debug", + LogFilePath = "./Logs/driver-update-.log", + EnableConsoleLogging = true, + EnableFileLogging = true, + DefaultBackupPath = "./Backups", + DefaultRetryCount = 5, + DefaultRetryIntervalSeconds = 10, + AutoCleanupBackups = true, + BackupsToKeep = 3 +}; + +// Create updater instance with custom configuration +var updater = GeneralDrivelution.Create(options); + +// Define update strategy +var strategy = new UpdateStrategy +{ + Mode = UpdateMode.Full, + ForceUpdate = false, + RequireBackup = true, + BackupPath = @"C:\DriverBackups\MyDevice", + RetryCount = 3, + RetryIntervalSeconds = 5, + TimeoutSeconds = 600, + RestartMode = RestartMode.Prompt, + SkipSignatureValidation = false, // Only set true in development + SkipHashValidation = false // Only set true in development +}; + +// Prepare driver info +var driverInfo = new DriverInfo +{ + Name = "High-Performance Network Adapter", + Version = "3.2.1", + FilePath = @"C:\Drivers\network-adapter-v3.2.1.sys", + TargetOS = "Windows", + Architecture = "x64", + HardwareId = "PCI\\VEN_8086&DEV_15B8&SUBSYS_12345678", + Hash = "a1b2c3d4e5f6789...", + HashAlgorithm = "SHA256", + Description = "High-Performance 10Gb Ethernet Adapter Driver", + ReleaseDate = DateTime.Parse("2026-01-15"), + TrustedPublishers = new List + { + "CN=MyCompany Inc., O=MyCompany Inc., L=City, S=State, C=US" + }, + Metadata = new Dictionary + { + { "Vendor", "MyCompany" }, + { "Category", "Network" }, + { "MinOSVersion", "10.0.19041" } + } +}; + +// Execute update +var result = await updater.UpdateAsync(driverInfo, strategy, cancellationToken); + +// Handle result +if (result.Success) +{ + Console.WriteLine($"✓ Update succeeded in {result.DurationMs}ms"); + Console.WriteLine($"Status: {result.Status}"); + + if (!string.IsNullOrEmpty(result.BackupPath)) + { + Console.WriteLine($"Backup: {result.BackupPath}"); + } + + // Display step logs + foreach (var log in result.StepLogs) + { + Console.WriteLine(log); + } +} +else +{ + Console.WriteLine($"✗ Update failed: {result.Error?.Message}"); + Console.WriteLine($"Error Type: {result.Error?.Type}"); + Console.WriteLine($"Can Retry: {result.Error?.CanRetry}"); + + if (result.RolledBack) + { + Console.WriteLine("✓ Successfully rolled back to previous version"); + } +} +``` + +## Core Concepts + +### Driver Information Model + +The `DriverInfo` class encapsulates all necessary information about a driver: + +```csharp +public class DriverInfo +{ + public string Name { get; set; } // Driver name + public string Version { get; set; } // SemVer 2.0 version + public string FilePath { get; set; } // Local or network path + public string TargetOS { get; set; } // "Windows", "Linux" + public string Architecture { get; set; } // "x86", "x64", "ARM", "ARM64" + public string HardwareId { get; set; } // Device hardware ID + public string Hash { get; set; } // File hash for integrity + public string HashAlgorithm { get; set; } // "SHA256", "MD5" + public List TrustedPublishers { get; set; } + public string Description { get; set; } + public DateTime ReleaseDate { get; set; } + public Dictionary Metadata { get; set; } +} +``` + +### Update Strategy + +The `UpdateStrategy` class defines how the update should be performed: + +```csharp +public class UpdateStrategy +{ + public UpdateMode Mode { get; set; } // Full or Incremental + public bool ForceUpdate { get; set; } // Cannot be cancelled + public bool RequireBackup { get; set; } // Create backup before update + public string BackupPath { get; set; } // Custom backup location + public int RetryCount { get; set; } // Number of retries on failure + public int RetryIntervalSeconds { get; set; } // Delay between retries + public int Priority { get; set; } // For batch updates + public RestartMode RestartMode { get; set; } // None, Prompt, Delayed, Immediate + public bool SkipSignatureValidation { get; set; } // Debug only + public bool SkipHashValidation { get; set; } // Debug only + public int TimeoutSeconds { get; set; } // Operation timeout +} +``` + +### Update Result + +The `UpdateResult` class provides detailed information about the update operation: + +```csharp +public class UpdateResult +{ + public bool Success { get; set; } // Overall success status + public UpdateStatus Status { get; set; } // Current status + public ErrorInfo? Error { get; set; } // Error details if failed + public DateTime StartTime { get; set; } // Start timestamp + public DateTime EndTime { get; set; } // End timestamp + public long DurationMs { get; } // Duration in milliseconds + public string? BackupPath { get; set; } // Backup location if created + public bool RolledBack { get; set; } // Whether rollback occurred + public string Message { get; set; } // Human-readable message + public List StepLogs { get; set; } // Detailed step-by-step logs +} +``` + +## Platform-Specific Features + +### Windows Platform + +#### Digital Signature Validation +```csharp +// Windows drivers must be signed by a trusted publisher +var driverInfo = new DriverInfo +{ + FilePath = @"C:\Drivers\device.sys", + TrustedPublishers = new List + { + "CN=Microsoft Windows Hardware Compatibility Publisher" + } +}; +``` + +#### Hardware ID Validation +```csharp +// Windows uses PnP hardware IDs +var driverInfo = new DriverInfo +{ + HardwareId = "PCI\\VEN_8086&DEV_15B8&SUBSYS_12345678&REV_01" +}; +``` + +#### Administrator Privileges +Windows driver updates automatically check for administrator privileges and will throw a `DriverPermissionException` if not running as administrator. + +### Linux Platform + +#### Kernel Module Installation +```csharp +// Linux drivers are typically kernel modules (.ko files) +var driverInfo = new DriverInfo +{ + FilePath = "/path/to/driver.ko", + TargetOS = "Linux", + Architecture = "x64" +}; +``` + +#### GPG Signature Validation +```csharp +// Linux drivers can be validated using GPG signatures +var options = new DriverUpdateOptions +{ + TrustedGpgKeys = new List + { + "1234567890ABCDEF1234567890ABCDEF12345678" + } +}; +``` + +#### Sudo Privileges +Linux driver updates automatically ensure sudo access and will request elevation when needed. + +## Validation Features + +### Hash Validation + +Ensures file integrity by comparing computed hash with expected hash: + +```csharp +// Validate driver file integrity before installation +var isValid = await updater.ValidateAsync(driverInfo); + +if (!isValid) +{ + Console.WriteLine("Driver file is corrupted or tampered with!"); +} +``` + +Supported algorithms: +- **SHA256** (recommended) +- **MD5** (legacy support) + +### Signature Validation + +Verifies digital signatures to ensure driver authenticity: + +**Windows**: Authenticode digital signatures +**Linux**: GPG signature verification + +```csharp +var strategy = new UpdateStrategy +{ + SkipSignatureValidation = false // Enable signature validation +}; +``` + +### Compatibility Validation + +Checks driver compatibility with target system: + +```csharp +var driverInfo = new DriverInfo +{ + TargetOS = "Windows", + Architecture = "x64", + Metadata = new Dictionary + { + { "MinOSVersion", "10.0.19041" } // Minimum Windows version + } +}; +``` + +## Backup and Rollback + +### Automatic Backup + +```csharp +var strategy = new UpdateStrategy +{ + RequireBackup = true, + BackupPath = @"C:\DriverBackups\MyDevice_2026-02-08" +}; + +var result = await updater.UpdateAsync(driverInfo, strategy); + +if (!string.IsNullOrEmpty(result.BackupPath)) +{ + Console.WriteLine($"Backup created at: {result.BackupPath}"); +} +``` + +### Manual Backup + +```csharp +var backupPath = @"C:\DriverBackups\Manual_" + DateTime.Now.ToString("yyyyMMdd_HHmmss"); +var success = await updater.BackupAsync(driverInfo, backupPath); + +if (success) +{ + Console.WriteLine($"Manual backup created: {backupPath}"); +} +``` + +### Rollback on Failure + +Automatic rollback is triggered when installation fails: + +```csharp +var result = await updater.UpdateAsync(driverInfo, strategy); + +if (result.RolledBack) +{ + Console.WriteLine("Installation failed but successfully rolled back"); + Console.WriteLine($"Previous driver restored from: {result.BackupPath}"); +} +``` + +### Manual Rollback + +```csharp +var backupPath = @"C:\DriverBackups\MyDevice_20260208"; +var success = await updater.RollbackAsync(backupPath); + +if (success) +{ + Console.WriteLine("Successfully restored from backup"); +} +``` + +## Error Handling + +### Exception Types + +The library provides specific exception types for different failure scenarios: + +```csharp +try +{ + var result = await updater.UpdateAsync(driverInfo, strategy); +} +catch (DriverPermissionException ex) +{ + // Insufficient permissions (not admin/sudo) + Console.WriteLine($"Permission denied: {ex.Message}"); + Console.WriteLine("Please run as administrator/sudo"); +} +catch (DriverValidationException ex) +{ + // Validation failed (hash, signature, compatibility) + Console.WriteLine($"Validation failed: {ex.Message}"); + Console.WriteLine($"Validation type: {ex.ValidationType}"); +} +catch (DriverInstallationException ex) +{ + // Installation failed + Console.WriteLine($"Installation failed: {ex.Message}"); + Console.WriteLine($"Can retry: {ex.CanRetry}"); + Console.WriteLine($"Error code: {ex.ErrorCode}"); +} +catch (DriverBackupException ex) +{ + // Backup operation failed + Console.WriteLine($"Backup failed: {ex.Message}"); +} +catch (DriverRollbackException ex) +{ + // Rollback operation failed + Console.WriteLine($"Rollback failed: {ex.Message}"); +} +``` + +### Error Information + +Detailed error information is available in the result: + +```csharp +if (!result.Success && result.Error != null) +{ + Console.WriteLine($"Error Type: {result.Error.Type}"); + Console.WriteLine($"Message: {result.Error.Message}"); + Console.WriteLine($"Details: {result.Error.Details}"); + Console.WriteLine($"Can Retry: {result.Error.CanRetry}"); + Console.WriteLine($"Error Code: {result.Error.ErrorCode}"); + Console.WriteLine($"Timestamp: {result.Error.Timestamp}"); +} +``` + +### Error Types + +```csharp +public enum ErrorType +{ + PermissionDenied, // Insufficient privileges + HashValidationFailed, // Hash mismatch + SignatureValidationFailed, // Invalid signature + CompatibilityCheckFailed, // Incompatible driver + InstallationFailed, // Installation error + BackupFailed, // Backup creation failed + RollbackFailed, // Rollback failed + NetworkError, // Download/network issue + TimeoutError, // Operation timed out + UnknownError // Unexpected error +} +``` + +## Retry Logic + +### Automatic Retry on Failure + +```csharp +var strategy = new UpdateStrategy +{ + RetryCount = 5, // Retry up to 5 times + RetryIntervalSeconds = 10, // Wait 10 seconds between retries + TimeoutSeconds = 600 // 10 minute timeout per attempt +}; + +var result = await updater.UpdateAsync(driverInfo, strategy); + +// Retries are logged in step logs +foreach (var log in result.StepLogs) +{ + Console.WriteLine(log); +} +``` + +### Manual Retry + +```csharp +int maxAttempts = 3; +UpdateResult? result = null; + +for (int attempt = 1; attempt <= maxAttempts; attempt++) +{ + Console.WriteLine($"Attempt {attempt}/{maxAttempts}"); + + result = await updater.UpdateAsync(driverInfo, strategy); + + if (result.Success) + { + break; + } + + if (result.Error?.CanRetry == false) + { + Console.WriteLine("Error is not retryable, aborting"); + break; + } + + if (attempt < maxAttempts) + { + Console.WriteLine($"Waiting 10 seconds before retry..."); + await Task.Delay(TimeSpan.FromSeconds(10)); + } +} +``` + +## Logging + +### Default Logging Configuration + +```csharp +// Default logger writes to console and file +var updater = GeneralDrivelution.Create(); +``` + +### Custom Logging Configuration + +```csharp +var options = new DriverUpdateOptions +{ + LogLevel = "Debug", // Verbose logging + LogFilePath = "./Logs/driver-update-.log", // Rolling file logs + EnableConsoleLogging = true, // Console output + EnableFileLogging = true // File output +}; + +var updater = GeneralDrivelution.Create(options); +``` + +### Using Custom Logger + +```csharp +using Serilog; + +var logger = new LoggerConfiguration() + .MinimumLevel.Information() + .WriteTo.Console() + .WriteTo.File("logs/custom-.log", rollingInterval: RollingInterval.Day) + .CreateLogger(); + +var updater = GeneralDrivelution.Create(logger, options); +``` + +### Log Levels + +- **Debug**: Detailed diagnostic information +- **Info**: General informational messages (default) +- **Warn**: Warning messages for potential issues +- **Error**: Error messages for failures +- **Fatal**: Critical errors that cause termination + +## Platform Detection + +### Get Platform Information + +```csharp +var platformInfo = GeneralDrivelution.GetPlatformInfo(); + +Console.WriteLine($"Platform: {platformInfo.Platform}"); +Console.WriteLine($"OS: {platformInfo.OperatingSystem}"); +Console.WriteLine($"Architecture: {platformInfo.Architecture}"); +Console.WriteLine($"Version: {platformInfo.SystemVersion}"); +Console.WriteLine($"Supported: {platformInfo.IsSupported}"); +``` + +Output example: +``` +Platform: Windows +OS: Microsoft Windows 10.0.19045 +Architecture: X64 +Version: 10.0.19045.0 +Supported: Yes +``` + +## Restart Management + +### Restart Modes + +```csharp +public enum RestartMode +{ + None, // No restart required + Prompt, // Prompt user to restart + Delayed, // Delayed restart + Immediate // Immediate restart +} +``` + +### Handling Restarts + +```csharp +var strategy = new UpdateStrategy +{ + RestartMode = RestartMode.Prompt +}; + +var result = await updater.UpdateAsync(driverInfo, strategy); + +if (result.Success) +{ + // Check if restart is required + if (result.Message.Contains("restart")) + { + Console.WriteLine("System restart required for changes to take effect"); + Console.Write("Restart now? (y/n): "); + + if (Console.ReadLine()?.ToLower() == "y") + { + // Implement restart logic + Process.Start("shutdown", "/r /t 0"); + } + } +} +``` + +## Version Comparison + +The library includes SemVer 2.0 compliant version comparison: + +```csharp +using GeneralUpdate.Drivelution.Core.Utilities; + +// Compare versions +int comparison = VersionComparer.Compare("2.1.0", "2.0.3"); +// Returns: 1 (2.1.0 > 2.0.3) + +// Check if update is available +bool updateAvailable = VersionComparer.IsGreaterThan("2.1.0", "2.0.3"); +// Returns: true + +// Semantic versioning with prerelease +bool isNewer = VersionComparer.IsGreaterThan("2.1.0", "2.1.0-beta.1"); +// Returns: true (release is greater than prerelease) +``` + +## Best Practices + +### 1. Always Validate Before Update + +```csharp +// Validate driver before attempting update +var isValid = await updater.ValidateAsync(driverInfo); + +if (!isValid) +{ + Console.WriteLine("Validation failed. Update aborted."); + return; +} + +var result = await updater.UpdateAsync(driverInfo, strategy); +``` + +### 2. Enable Backups for Production + +```csharp +var strategy = new UpdateStrategy +{ + RequireBackup = true, // Always backup in production + BackupPath = GenerateUniqueBackupPath(), // Use unique paths + SkipSignatureValidation = false, // Never skip in production + SkipHashValidation = false // Never skip in production +}; +``` + +### 3. Use Appropriate Retry Settings + +```csharp +var strategy = new UpdateStrategy +{ + RetryCount = 3, // Reasonable retry count + RetryIntervalSeconds = 5, // Short interval for fast recovery + TimeoutSeconds = 300 // 5 minute timeout +}; +``` + +### 4. Handle Cancellation Properly + +```csharp +var cts = new CancellationTokenSource(); +cts.CancelAfter(TimeSpan.FromMinutes(10)); // Maximum 10 minutes + +try +{ + var result = await updater.UpdateAsync(driverInfo, strategy, cts.Token); +} +catch (OperationCanceledException) +{ + Console.WriteLine("Update cancelled by user or timeout"); +} +``` + +### 5. Log Everything + +```csharp +var options = new DriverUpdateOptions +{ + LogLevel = "Info", // Use Info level in production + EnableFileLogging = true, // Keep file logs for auditing + EnableConsoleLogging = false // Disable console in services +}; +``` + +### 6. Clean Up Old Backups + +```csharp +var options = new DriverUpdateOptions +{ + AutoCleanupBackups = true, // Enable automatic cleanup + BackupsToKeep = 5 // Keep last 5 backups +}; +``` + +### 7. Test with Skip Flags First + +```csharp +// Development/Testing only +#if DEBUG +var strategy = new UpdateStrategy +{ + SkipSignatureValidation = true, // Skip for unsigned test drivers + SkipHashValidation = false // Still validate hash +}; +#else +var strategy = new UpdateStrategy +{ + SkipSignatureValidation = false, // Always validate in production + SkipHashValidation = false +}; +#endif +``` + +## Common Scenarios + +### Scenario 1: Silent Background Update + +```csharp +public async Task PerformSilentUpdateAsync(DriverInfo driverInfo) +{ + var options = new DriverUpdateOptions + { + EnableConsoleLogging = false, // No console output + EnableFileLogging = true, // Log to file + LogLevel = "Info" + }; + + var updater = GeneralDrivelution.Create(options); + + var strategy = new UpdateStrategy + { + RequireBackup = true, + RetryCount = 3, + RestartMode = RestartMode.Delayed // Don't restart immediately + }; + + var result = await updater.UpdateAsync(driverInfo, strategy); + + return result.Success; +} +``` + +### Scenario 2: Interactive Update with Progress + +```csharp +public async Task InteractiveUpdateAsync(DriverInfo driverInfo) +{ + Console.WriteLine("Starting driver update..."); + + var strategy = new UpdateStrategy + { + RequireBackup = true, + RetryCount = 3, + RestartMode = RestartMode.Prompt + }; + + var updater = GeneralDrivelution.Create(); + var result = await updater.UpdateAsync(driverInfo, strategy); + + // Display detailed logs + Console.WriteLine("\n=== Update Log ==="); + foreach (var log in result.StepLogs) + { + Console.WriteLine(log); + } + + if (result.Success) + { + Console.WriteLine($"\n✓ Update completed successfully in {result.DurationMs}ms"); + } + else + { + Console.WriteLine($"\n✗ Update failed: {result.Error?.Message}"); + } + + return result; +} +``` + +### Scenario 3: Batch Driver Updates + +```csharp +public async Task> BatchUpdateAsync(List drivers) +{ + var results = new List(); + var updater = GeneralDrivelution.Create(); + + foreach (var driver in drivers.OrderByDescending(d => d.Metadata.GetValueOrDefault("Priority", "0"))) + { + Console.WriteLine($"\nUpdating: {driver.Name} v{driver.Version}"); + + var strategy = new UpdateStrategy + { + RequireBackup = true, + RetryCount = 2, + RestartMode = RestartMode.None // Restart once at the end + }; + + var result = await updater.UpdateAsync(driver, strategy); + results.Add(result); + + if (!result.Success) + { + Console.WriteLine($"Failed to update {driver.Name}, continuing with next driver..."); + } + } + + // Check if any update requires restart + if (results.Any(r => r.Success)) + { + Console.WriteLine("\nAll updates completed. System restart recommended."); + } + + return results; +} +``` + +### Scenario 4: Update with Download + +```csharp +public async Task DownloadAndUpdateAsync(string downloadUrl, DriverInfo driverInfo) +{ + var httpClient = new HttpClient(); + + // Download driver file + Console.WriteLine($"Downloading driver from {downloadUrl}..."); + var downloadPath = Path.Combine(Path.GetTempPath(), Path.GetFileName(downloadUrl)); + + using (var response = await httpClient.GetAsync(downloadUrl)) + { + response.EnsureSuccessStatusCode(); + await using var fs = new FileStream(downloadPath, FileMode.Create); + await response.Content.CopyToAsync(fs); + } + + Console.WriteLine("Download complete. Verifying..."); + + // Update driver info with downloaded file + driverInfo.FilePath = downloadPath; + + // Perform update + var updater = GeneralDrivelution.Create(); + var strategy = new UpdateStrategy + { + RequireBackup = true, + SkipHashValidation = false // Verify downloaded file + }; + + var result = await updater.UpdateAsync(driverInfo, strategy); + + // Clean up downloaded file if update succeeded + if (result.Success) + { + try { File.Delete(downloadPath); } catch { } + } + + return result; +} +``` + +## Troubleshooting + +### Issue: "Administrator privileges are required" + +**Solution**: Run your application as Administrator (Windows) or with sudo (Linux). + +Windows: +```bash +# Run as administrator +runas /user:Administrator "YourApp.exe" +``` + +Linux: +```bash +# Run with sudo +sudo ./YourApp +``` + +### Issue: "Driver validation failed" + +**Possible causes**: +1. Hash mismatch - file is corrupted or tampered with +2. Invalid signature - driver is not properly signed +3. Incompatible driver - wrong OS or architecture + +**Solution**: +```csharp +// Enable detailed logging to identify the specific validation failure +var options = new DriverUpdateOptions { LogLevel = "Debug" }; +var updater = GeneralDrivelution.Create(options); + +// Try validation separately +var isValid = await updater.ValidateAsync(driverInfo); +``` + +### Issue: "Installation failed" + +**Solution**: Check the error details and retry if possible: + +```csharp +if (!result.Success) +{ + Console.WriteLine($"Error: {result.Error?.Message}"); + Console.WriteLine($"Details: {result.Error?.Details}"); + + if (result.Error?.CanRetry == true) + { + // Retry the operation + result = await updater.UpdateAsync(driverInfo, strategy); + } +} +``` + +### Issue: "Backup failed" + +**Solution**: Ensure sufficient disk space and write permissions: + +```csharp +var backupPath = @"C:\DriverBackups"; + +// Ensure directory exists and is writable +Directory.CreateDirectory(backupPath); + +// Check available space +var drive = new DriveInfo(Path.GetPathRoot(backupPath)); +if (drive.AvailableFreeSpace < 100_000_000) // 100 MB +{ + Console.WriteLine("Insufficient disk space for backup"); +} +``` + +### Issue: "Platform not supported" + +**Solution**: Check platform compatibility: + +```csharp +var platformInfo = GeneralDrivelution.GetPlatformInfo(); + +if (!platformInfo.IsSupported) +{ + Console.WriteLine($"Platform {platformInfo.Platform} is not supported"); + Console.WriteLine("Supported platforms: Windows (8+), Linux (Ubuntu 18.04+)"); +} +``` + +## Performance Considerations + +### 1. File I/O Optimization + +The library uses async I/O for all file operations to avoid blocking: + +```csharp +// All operations are async +var result = await updater.UpdateAsync(driverInfo, strategy); +var isValid = await updater.ValidateAsync(driverInfo); +var backed = await updater.BackupAsync(driverInfo, backupPath); +``` + +### 2. Hash Computation + +Hash validation is performed asynchronously in chunks to handle large files efficiently: + +```csharp +// Efficient for large driver files (100+ MB) +var hash = await HashValidator.ComputeHashAsync(filePath, "SHA256"); +``` + +### 3. Timeout Settings + +Configure appropriate timeouts based on file size and system performance: + +```csharp +var strategy = new UpdateStrategy +{ + TimeoutSeconds = 300 // 5 minutes for typical drivers + // Increase for large drivers (500+ MB) +}; +``` + +## Security Considerations + +### 1. Always Validate Signatures + +```csharp +// Production configuration +var strategy = new UpdateStrategy +{ + SkipSignatureValidation = false, // Never skip in production + SkipHashValidation = false +}; +``` + +### 2. Use Strong Hash Algorithms + +```csharp +var driverInfo = new DriverInfo +{ + HashAlgorithm = "SHA256" // Preferred over MD5 +}; +``` + +### 3. Verify Publisher Trust + +```csharp +var driverInfo = new DriverInfo +{ + TrustedPublishers = new List + { + "CN=YourCompany, O=YourCompany, C=US" + } +}; +``` + +### 4. Secure Backup Storage + +```csharp +// Store backups in a secure location +var strategy = new UpdateStrategy +{ + BackupPath = @"C:\SecureBackups\Drivers" // Use appropriate ACLs +}; +``` + +## API Reference + +### GeneralDrivelution (Static Class) + +```csharp +// Create updater with default options +IGeneralDrivelution Create(DriverUpdateOptions? options = null) + +// Create updater with custom logger +IGeneralDrivelution Create(ILogger logger, DriverUpdateOptions? options = null) + +// Quick update with default settings +Task QuickUpdateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default) + +// Quick update with custom strategy +Task QuickUpdateAsync(DriverInfo driverInfo, UpdateStrategy strategy, CancellationToken cancellationToken = default) + +// Validate driver +Task ValidateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default) + +// Get platform information +PlatformInfo GetPlatformInfo() +``` + +### IGeneralDrivelution Interface + +```csharp +// Update driver +Task UpdateAsync(DriverInfo driverInfo, UpdateStrategy strategy, CancellationToken cancellationToken = default) + +// Validate driver +Task ValidateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default) + +// Backup driver +Task BackupAsync(DriverInfo driverInfo, string backupPath, CancellationToken cancellationToken = default) + +// Rollback driver +Task RollbackAsync(string backupPath, CancellationToken cancellationToken = default) +``` + +## Contributing + +Contributions are welcome! Please see the main repository for contribution guidelines. + +## License + +This project is licensed under the Apache 2.0 License. See the LICENSE file for details. + +## Support + +- **Documentation**: [https://www.justerzhu.cn/](https://www.justerzhu.cn/) +- **Issues**: [GitHub Issues](https://github.com/GeneralLibrary/GeneralUpdate/issues) +- **Discussions**: Join the discussion group (contact information in main README) + +## Related Projects + +- **GeneralUpdate**: Main automatic update framework +- **GeneralUpdate.Tools**: Update patch creation tool +- **GeneralUpdate.Maui**: Mobile update support (Android) +- **GeneralUpdate-Samples**: Usage examples + +## Changelog + +### Version 1.0.0 (2026-02-08) +- Initial release +- Windows and Linux platform support +- Comprehensive validation (hash, signature, compatibility) +- Backup and rollback mechanisms +- Configurable retry logic +- Detailed logging with Serilog +- AOT compatibility + +## Roadmap + +### Upcoming Features +- [ ] macOS platform support +- [ ] Progress reporting callbacks +- [ ] Concurrent driver updates +- [ ] Advanced dependency management +- [ ] Remote driver repository support +- [ ] Automatic driver discovery +- [ ] Web-based management dashboard + +--- + +**Note**: This library is part of the GeneralUpdate ecosystem. For complete application update solutions, see the main GeneralUpdate framework. From 24782beaa478d6c56fc5eeecc8ca52a87de79435 Mon Sep 17 00:00:00 2001 From: Copilot <198982749+Copilot@users.noreply.github.com> Date: Mon, 9 Feb 2026 01:07:44 +0800 Subject: [PATCH 3/5] Add comprehensive test suite for GeneralUpdate.Drivelution (#140) * Initial plan * Add comprehensive test cases for GeneralUpdate.Drivelution Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> * Address code review feedback: improve test quality and cleanup Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> --- .../Core/DriverUpdaterFactoryTests.cs | 212 ++++++++++ src/c#/DrivelutionTest/DrivelutionTest.csproj | 28 ++ .../GeneralDrivelutionTests.cs | 330 +++++++++++++++ src/c#/DrivelutionTest/Models/ModelTests.cs | 383 +++++++++++++++++ .../Utilities/CompatibilityCheckerTests.cs | 335 +++++++++++++++ .../Utilities/HashValidatorTests.cs | 237 +++++++++++ .../VersionComparerAndRestartHelperTests.cs | 384 ++++++++++++++++++ 7 files changed, 1909 insertions(+) create mode 100644 src/c#/DrivelutionTest/Core/DriverUpdaterFactoryTests.cs create mode 100644 src/c#/DrivelutionTest/DrivelutionTest.csproj create mode 100644 src/c#/DrivelutionTest/GeneralDrivelutionTests.cs create mode 100644 src/c#/DrivelutionTest/Models/ModelTests.cs create mode 100644 src/c#/DrivelutionTest/Utilities/CompatibilityCheckerTests.cs create mode 100644 src/c#/DrivelutionTest/Utilities/HashValidatorTests.cs create mode 100644 src/c#/DrivelutionTest/Utilities/VersionComparerAndRestartHelperTests.cs diff --git a/src/c#/DrivelutionTest/Core/DriverUpdaterFactoryTests.cs b/src/c#/DrivelutionTest/Core/DriverUpdaterFactoryTests.cs new file mode 100644 index 00000000..75feab57 --- /dev/null +++ b/src/c#/DrivelutionTest/Core/DriverUpdaterFactoryTests.cs @@ -0,0 +1,212 @@ +using GeneralUpdate.Drivelution.Core; +using GeneralUpdate.Drivelution.Abstractions; +using GeneralUpdate.Drivelution.Abstractions.Configuration; +using Serilog; +using Serilog.Core; + +namespace DrivelutionTest.Core; + +/// +/// Tests for DriverUpdaterFactory class. +/// Validates platform detection, factory creation, and platform-specific implementations. +/// +public class DriverUpdaterFactoryTests +{ + /// + /// Tests that Create method returns a non-null instance. + /// + [Fact] + public void Create_WithoutParameters_ReturnsNonNullInstance() + { + // Arrange & Act + var updater = DriverUpdaterFactory.Create(); + + // Assert + Assert.NotNull(updater); + Assert.IsAssignableFrom(updater); + } + + /// + /// Tests that Create method accepts custom logger. + /// + [Fact] + public void Create_WithCustomLogger_ReturnsInstance() + { + // Arrange + var logger = new LoggerConfiguration() + .MinimumLevel.Debug() + .WriteTo.Console() + .CreateLogger(); + + // Act + var updater = DriverUpdaterFactory.Create(logger); + + // Assert + Assert.NotNull(updater); + Assert.IsAssignableFrom(updater); + } + + /// + /// Tests that Create method accepts custom options. + /// + [Fact] + public void Create_WithCustomOptions_ReturnsInstance() + { + // Arrange + var options = new DriverUpdateOptions + { + LogLevel = "Debug", + LogFilePath = "./logs/test.log" + }; + + // Act + var updater = DriverUpdaterFactory.Create(null, options); + + // Assert + Assert.NotNull(updater); + } + + /// + /// Tests that GetCurrentPlatform returns a valid platform name. + /// + [Fact] + public void GetCurrentPlatform_ReturnsValidPlatformName() + { + // Act + var platform = DriverUpdaterFactory.GetCurrentPlatform(); + + // Assert + Assert.NotNull(platform); + Assert.Contains(platform, new[] { "Windows", "Linux", "MacOS", "Unknown" }); + } + + /// + /// Tests that IsPlatformSupported returns a boolean value. + /// + [Fact] + public void IsPlatformSupported_ReturnsBooleanValue() + { + // Act + var isSupported = DriverUpdaterFactory.IsPlatformSupported(); + + // Assert + // Windows and Linux should be supported + Assert.True(isSupported || DriverUpdaterFactory.GetCurrentPlatform() == "MacOS" || DriverUpdaterFactory.GetCurrentPlatform() == "Unknown"); + } + + /// + /// Tests that CreateValidator returns a non-null instance. + /// + [Fact] + public void CreateValidator_WithoutLogger_ReturnsNonNullInstance() + { + // Skip on MacOS and Unknown platforms + var platform = DriverUpdaterFactory.GetCurrentPlatform(); + if (platform == "MacOS" || platform == "Unknown") + { + return; + } + + // Act + var validator = DriverUpdaterFactory.CreateValidator(); + + // Assert + Assert.NotNull(validator); + Assert.IsAssignableFrom(validator); + } + + /// + /// Tests that CreateBackup returns a non-null instance. + /// + [Fact] + public void CreateBackup_WithoutLogger_ReturnsNonNullInstance() + { + // Skip on MacOS and Unknown platforms + var platform = DriverUpdaterFactory.GetCurrentPlatform(); + if (platform == "MacOS" || platform == "Unknown") + { + return; + } + + // Act + var backup = DriverUpdaterFactory.CreateBackup(); + + // Assert + Assert.NotNull(backup); + Assert.IsAssignableFrom(backup); + } + + /// + /// Tests that CreateValidator with custom logger works correctly. + /// + [Fact] + public void CreateValidator_WithCustomLogger_ReturnsInstance() + { + // Skip on MacOS and Unknown platforms + var platform = DriverUpdaterFactory.GetCurrentPlatform(); + if (platform == "MacOS" || platform == "Unknown") + { + return; + } + + // Arrange + var logger = new LoggerConfiguration() + .MinimumLevel.Debug() + .WriteTo.Console() + .CreateLogger(); + + // Act + var validator = DriverUpdaterFactory.CreateValidator(logger); + + // Assert + Assert.NotNull(validator); + } + + /// + /// Tests that CreateBackup with custom logger works correctly. + /// + [Fact] + public void CreateBackup_WithCustomLogger_ReturnsInstance() + { + // Skip on MacOS and Unknown platforms + var platform = DriverUpdaterFactory.GetCurrentPlatform(); + if (platform == "MacOS" || platform == "Unknown") + { + return; + } + + // Arrange + var logger = new LoggerConfiguration() + .MinimumLevel.Debug() + .WriteTo.Console() + .CreateLogger(); + + // Act + var backup = DriverUpdaterFactory.CreateBackup(logger); + + // Assert + Assert.NotNull(backup); + } + + /// + /// Tests that Create throws PlatformNotSupportedException on unsupported platforms. + /// This test documents expected behavior but cannot be easily tested on supported platforms. + /// + [Fact] + public void Create_OnSupportedPlatform_DoesNotThrow() + { + // Skip on MacOS as it's not yet implemented + var platform = DriverUpdaterFactory.GetCurrentPlatform(); + + if (platform == "MacOS") + { + // MacOS should throw PlatformNotSupportedException + Assert.Throws(() => DriverUpdaterFactory.Create()); + return; + } + + // Act & Assert - should not throw on Windows/Linux + var exception = Record.Exception(() => DriverUpdaterFactory.Create()); + Assert.Null(exception); + } +} diff --git a/src/c#/DrivelutionTest/DrivelutionTest.csproj b/src/c#/DrivelutionTest/DrivelutionTest.csproj new file mode 100644 index 00000000..7c3fec32 --- /dev/null +++ b/src/c#/DrivelutionTest/DrivelutionTest.csproj @@ -0,0 +1,28 @@ + + + + net8.0 + enable + enable + + false + true + + + + + + + + + + + + + + + + + + + diff --git a/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs b/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs new file mode 100644 index 00000000..c7460e4f --- /dev/null +++ b/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs @@ -0,0 +1,330 @@ +using GeneralUpdate.Drivelution; +using GeneralUpdate.Drivelution.Abstractions.Models; +using GeneralUpdate.Drivelution.Abstractions.Configuration; +using Serilog; + +namespace DrivelutionTest; + +/// +/// Tests for GeneralDrivelution static entry point class. +/// Validates factory methods, quick update methods, and platform info retrieval. +/// +public class GeneralDrivelutionTests +{ + /// + /// Tests that Create method returns a non-null instance. + /// + [Fact] + public void Create_WithoutParameters_ReturnsNonNullInstance() + { + // Act + var updater = GeneralDrivelution.Create(); + + // Assert + Assert.NotNull(updater); + } + + /// + /// Tests that Create method with options returns a non-null instance. + /// + [Fact] + public void Create_WithOptions_ReturnsNonNullInstance() + { + // Arrange + var options = new DriverUpdateOptions + { + LogLevel = "Information", + LogFilePath = "./logs/test.log" + }; + + // Act + var updater = GeneralDrivelution.Create(options); + + // Assert + Assert.NotNull(updater); + } + + /// + /// Tests that Create method with custom logger returns a non-null instance. + /// + [Fact] + public void Create_WithCustomLogger_ReturnsNonNullInstance() + { + // Arrange + var logger = new LoggerConfiguration() + .MinimumLevel.Debug() + .WriteTo.Console() + .CreateLogger(); + + // Act + var updater = GeneralDrivelution.Create(logger); + + // Assert + Assert.NotNull(updater); + } + + /// + /// Tests that Create method with custom logger and options returns instance. + /// + [Fact] + public void Create_WithCustomLoggerAndOptions_ReturnsInstance() + { + // Arrange + var logger = new LoggerConfiguration() + .MinimumLevel.Debug() + .WriteTo.Console() + .CreateLogger(); + var options = new DriverUpdateOptions + { + LogLevel = "Debug" + }; + + // Act + var updater = GeneralDrivelution.Create(logger, options); + + // Assert + Assert.NotNull(updater); + } + + /// + /// Tests that GetPlatformInfo returns valid platform information. + /// + [Fact] + public void GetPlatformInfo_ReturnsValidPlatformInfo() + { + // Act + var platformInfo = GeneralDrivelution.GetPlatformInfo(); + + // Assert + Assert.NotNull(platformInfo); + Assert.NotNull(platformInfo.Platform); + Assert.NotEmpty(platformInfo.Platform); + Assert.NotNull(platformInfo.OperatingSystem); + Assert.NotEmpty(platformInfo.OperatingSystem); + Assert.NotNull(platformInfo.Architecture); + Assert.NotEmpty(platformInfo.Architecture); + Assert.NotNull(platformInfo.SystemVersion); + Assert.NotEmpty(platformInfo.SystemVersion); + } + + /// + /// Tests that PlatformInfo ToString returns a valid string. + /// + [Fact] + public void PlatformInfo_ToString_ReturnsValidString() + { + // Arrange + var platformInfo = GeneralDrivelution.GetPlatformInfo(); + + // Act + var result = platformInfo.ToString(); + + // Assert + Assert.NotNull(result); + Assert.NotEmpty(result); + Assert.Contains(platformInfo.Platform, result); + Assert.Contains(platformInfo.OperatingSystem, result); + } + + /// + /// Tests that QuickUpdateAsync with minimal parameters works (or throws expected exceptions). + /// + [Fact] + public async Task QuickUpdateAsync_WithMinimalParameters_HandlesGracefully() + { + // Arrange + var testFilePath = Path.Combine(Path.GetTempPath(), $"test_driver_{Guid.NewGuid()}.txt"); + File.WriteAllText(testFilePath, "Test driver content"); + + try + { + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + FilePath = testFilePath, + TargetOS = "", + Architecture = "" + }; + + // Act + var result = await GeneralDrivelution.QuickUpdateAsync(driverInfo); + + // Assert + Assert.NotNull(result); + // The result might fail due to validation or permissions, but should not crash + // Verify that result status is one of the valid enum values + Assert.True(Enum.IsDefined(typeof(UpdateStatus), result.Status)); + } + finally + { + if (File.Exists(testFilePath)) + { + File.Delete(testFilePath); + } + } + } + + /// + /// Tests that QuickUpdateAsync with custom strategy works. + /// + [Fact] + public async Task QuickUpdateAsync_WithCustomStrategy_HandlesGracefully() + { + // Arrange + var testFilePath = Path.Combine(Path.GetTempPath(), $"test_driver_{Guid.NewGuid()}.txt"); + File.WriteAllText(testFilePath, "Test driver content"); + + try + { + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + FilePath = testFilePath, + TargetOS = "", + Architecture = "" + }; + + var strategy = new UpdateStrategy + { + RequireBackup = false, + RetryCount = 1, + RetryIntervalSeconds = 1 + }; + + // Act + var result = await GeneralDrivelution.QuickUpdateAsync(driverInfo, strategy); + + // Assert + Assert.NotNull(result); + // Verify that result status is one of the valid enum values + Assert.True(Enum.IsDefined(typeof(UpdateStatus), result.Status)); + } + finally + { + if (File.Exists(testFilePath)) + { + File.Delete(testFilePath); + } + } + } + + /// + /// Tests that ValidateAsync with minimal driver info works. + /// + [Fact] + public async Task ValidateAsync_WithMinimalDriverInfo_ReturnsBooleanResult() + { + // Arrange + var testFilePath = Path.Combine(Path.GetTempPath(), $"test_driver_{Guid.NewGuid()}.txt"); + File.WriteAllText(testFilePath, "Test driver content"); + + try + { + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + FilePath = testFilePath, + TargetOS = "", + Architecture = "" + }; + + // Act + var result = await GeneralDrivelution.ValidateAsync(driverInfo); + + // Assert - Should return a boolean value without throwing + // No assertion needed - the test passes if no exception is thrown + } + finally + { + if (File.Exists(testFilePath)) + { + File.Delete(testFilePath); + } + } + } + + /// + /// Tests that ValidateAsync returns false for non-existent file. + /// + [Fact] + public async Task ValidateAsync_WithNonExistentFile_ReturnsFalse() + { + // Arrange + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + FilePath = "/nonexistent/path/driver.sys", + TargetOS = "", + Architecture = "" + }; + + // Act + var result = await GeneralDrivelution.ValidateAsync(driverInfo); + + // Assert + Assert.False(result); + } + + /// + /// Tests that QuickUpdateAsync with cancellation token works. + /// + [Fact] + public async Task QuickUpdateAsync_WithCancellationToken_CanBeCancelled() + { + // Arrange + var testFilePath = Path.Combine(Path.GetTempPath(), $"test_driver_{Guid.NewGuid()}.txt"); + File.WriteAllText(testFilePath, "Test driver content"); + + try + { + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + FilePath = testFilePath + }; + + var cts = new CancellationTokenSource(); + cts.Cancel(); + + // Act & Assert + // Should either complete quickly or throw cancellation exception + var exception = await Record.ExceptionAsync( + () => GeneralDrivelution.QuickUpdateAsync(driverInfo, cts.Token)); + + // Either succeeded, failed gracefully, or was cancelled + Assert.True(exception == null || exception is OperationCanceledException); + } + finally + { + if (File.Exists(testFilePath)) + { + File.Delete(testFilePath); + } + } + } + + /// + /// Tests that GetPlatformInfo reports correct support status. + /// + [Fact] + public void GetPlatformInfo_ReportsCorrectSupportStatus() + { + // Act + var platformInfo = GeneralDrivelution.GetPlatformInfo(); + + // Assert + if (platformInfo.Platform == "Windows" || platformInfo.Platform == "Linux") + { + Assert.True(platformInfo.IsSupported); + } + else if (platformInfo.Platform == "MacOS") + { + Assert.False(platformInfo.IsSupported); // MacOS not yet implemented + } + } +} diff --git a/src/c#/DrivelutionTest/Models/ModelTests.cs b/src/c#/DrivelutionTest/Models/ModelTests.cs new file mode 100644 index 00000000..9e788f9e --- /dev/null +++ b/src/c#/DrivelutionTest/Models/ModelTests.cs @@ -0,0 +1,383 @@ +using GeneralUpdate.Drivelution.Abstractions.Models; + +namespace DrivelutionTest.Models; + +/// +/// Tests for DriverInfo model class. +/// Validates driver information structure and properties. +/// +public class DriverInfoTests +{ + /// + /// Tests that DriverInfo can be instantiated with default values. + /// + [Fact] + public void Constructor_CreatesInstanceWithDefaultValues() + { + // Act + var driverInfo = new DriverInfo(); + + // Assert + Assert.NotNull(driverInfo); + Assert.Equal(string.Empty, driverInfo.Name); + Assert.Equal(string.Empty, driverInfo.Version); + Assert.Equal(string.Empty, driverInfo.FilePath); + Assert.Equal("SHA256", driverInfo.HashAlgorithm); + Assert.NotNull(driverInfo.TrustedPublishers); + Assert.Empty(driverInfo.TrustedPublishers); + Assert.NotNull(driverInfo.Metadata); + Assert.Empty(driverInfo.Metadata); + } + + /// + /// Tests that DriverInfo properties can be set and retrieved. + /// + [Fact] + public void Properties_CanBeSetAndRetrieved() + { + // Arrange + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.2.3", + FilePath = "/path/to/driver.sys", + TargetOS = "Windows", + Architecture = "X64", + HardwareId = "PCI\\VEN_1234&DEV_5678", + Hash = "abc123", + HashAlgorithm = "SHA256", + Description = "Test driver description", + ReleaseDate = new DateTime(2024, 1, 1) + }; + + // Act & Assert + Assert.Equal("Test Driver", driverInfo.Name); + Assert.Equal("1.2.3", driverInfo.Version); + Assert.Equal("/path/to/driver.sys", driverInfo.FilePath); + Assert.Equal("Windows", driverInfo.TargetOS); + Assert.Equal("X64", driverInfo.Architecture); + Assert.Equal("PCI\\VEN_1234&DEV_5678", driverInfo.HardwareId); + Assert.Equal("abc123", driverInfo.Hash); + Assert.Equal("SHA256", driverInfo.HashAlgorithm); + Assert.Equal("Test driver description", driverInfo.Description); + Assert.Equal(new DateTime(2024, 1, 1), driverInfo.ReleaseDate); + } + + /// + /// Tests that TrustedPublishers list can be modified. + /// + [Fact] + public void TrustedPublishers_CanBeModified() + { + // Arrange + var driverInfo = new DriverInfo(); + + // Act + driverInfo.TrustedPublishers.Add("Microsoft Corporation"); + driverInfo.TrustedPublishers.Add("NVIDIA Corporation"); + + // Assert + Assert.Equal(2, driverInfo.TrustedPublishers.Count); + Assert.Contains("Microsoft Corporation", driverInfo.TrustedPublishers); + Assert.Contains("NVIDIA Corporation", driverInfo.TrustedPublishers); + } + + /// + /// Tests that Metadata dictionary can be modified. + /// + [Fact] + public void Metadata_CanBeModified() + { + // Arrange + var driverInfo = new DriverInfo(); + + // Act + driverInfo.Metadata["Author"] = "Test Author"; + driverInfo.Metadata["License"] = "MIT"; + driverInfo.Metadata["Website"] = "https://example.com"; + + // Assert + Assert.Equal(3, driverInfo.Metadata.Count); + Assert.Equal("Test Author", driverInfo.Metadata["Author"]); + Assert.Equal("MIT", driverInfo.Metadata["License"]); + Assert.Equal("https://example.com", driverInfo.Metadata["Website"]); + } + + /// + /// Tests that HashAlgorithm defaults to SHA256. + /// + [Fact] + public void HashAlgorithm_DefaultsToSHA256() + { + // Arrange & Act + var driverInfo = new DriverInfo(); + + // Assert + Assert.Equal("SHA256", driverInfo.HashAlgorithm); + } +} + +/// +/// Tests for UpdateStrategy model class. +/// Validates update strategy configuration and properties. +/// +public class UpdateStrategyTests +{ + /// + /// Tests that UpdateStrategy can be instantiated with default values. + /// + [Fact] + public void Constructor_CreatesInstanceWithDefaultValues() + { + // Act + var strategy = new UpdateStrategy(); + + // Assert + Assert.NotNull(strategy); + Assert.Equal(UpdateMode.Full, strategy.Mode); + Assert.False(strategy.ForceUpdate); + Assert.True(strategy.RequireBackup); + Assert.Equal(3, strategy.RetryCount); + Assert.Equal(5, strategy.RetryIntervalSeconds); + Assert.Equal(0, strategy.Priority); + Assert.Equal(RestartMode.Prompt, strategy.RestartMode); + Assert.False(strategy.SkipSignatureValidation); + Assert.False(strategy.SkipHashValidation); + Assert.Equal(300, strategy.TimeoutSeconds); + } + + /// + /// Tests that UpdateStrategy properties can be set and retrieved. + /// + [Fact] + public void Properties_CanBeSetAndRetrieved() + { + // Arrange + var strategy = new UpdateStrategy + { + Mode = UpdateMode.Incremental, + ForceUpdate = true, + RequireBackup = false, + BackupPath = "/backup", + RetryCount = 5, + RetryIntervalSeconds = 10, + Priority = 1, + RestartMode = RestartMode.Immediate, + SkipSignatureValidation = true, + SkipHashValidation = true, + TimeoutSeconds = 600 + }; + + // Act & Assert + Assert.Equal(UpdateMode.Incremental, strategy.Mode); + Assert.True(strategy.ForceUpdate); + Assert.False(strategy.RequireBackup); + Assert.Equal("/backup", strategy.BackupPath); + Assert.Equal(5, strategy.RetryCount); + Assert.Equal(10, strategy.RetryIntervalSeconds); + Assert.Equal(1, strategy.Priority); + Assert.Equal(RestartMode.Immediate, strategy.RestartMode); + Assert.True(strategy.SkipSignatureValidation); + Assert.True(strategy.SkipHashValidation); + Assert.Equal(600, strategy.TimeoutSeconds); + } + + /// + /// Tests UpdateMode enum values. + /// + [Fact] + public void UpdateMode_HasExpectedValues() + { + // Assert + Assert.Equal(0, (int)UpdateMode.Full); + Assert.Equal(1, (int)UpdateMode.Incremental); + } + + /// + /// Tests RestartMode enum values. + /// + [Fact] + public void RestartMode_HasExpectedValues() + { + // Assert + Assert.Equal(0, (int)RestartMode.None); + Assert.Equal(1, (int)RestartMode.Prompt); + Assert.Equal(2, (int)RestartMode.Delayed); + Assert.Equal(3, (int)RestartMode.Immediate); + } +} + +/// +/// Tests for UpdateResult model class. +/// Validates update result tracking and properties. +/// +public class UpdateResultTests +{ + /// + /// Tests that UpdateResult can be instantiated. + /// + [Fact] + public void Constructor_CreatesInstance() + { + // Act + var result = new UpdateResult(); + + // Assert + Assert.NotNull(result); + Assert.False(result.Success); + Assert.Equal(UpdateStatus.NotStarted, result.Status); + Assert.NotNull(result.StepLogs); + Assert.Empty(result.StepLogs); + Assert.Equal(string.Empty, result.Message); + } + + /// + /// Tests that UpdateResult properties can be set and retrieved. + /// + [Fact] + public void Properties_CanBeSetAndRetrieved() + { + // Arrange + var startTime = DateTime.UtcNow; + var endTime = startTime.AddMinutes(5); + var error = new ErrorInfo + { + Code = "TEST_ERROR", + Message = "Test error message" + }; + + var result = new UpdateResult + { + Success = true, + Status = UpdateStatus.Succeeded, + Error = error, + StartTime = startTime, + EndTime = endTime, + BackupPath = "/backup/path", + RolledBack = false, + Message = "Update completed" + }; + + // Act & Assert + Assert.True(result.Success); + Assert.Equal(UpdateStatus.Succeeded, result.Status); + Assert.Equal(error, result.Error); + Assert.Equal(startTime, result.StartTime); + Assert.Equal(endTime, result.EndTime); + Assert.Equal("/backup/path", result.BackupPath); + Assert.False(result.RolledBack); + Assert.Equal("Update completed", result.Message); + } + + /// + /// Tests that DurationMs is calculated correctly. + /// + [Fact] + public void DurationMs_CalculatesCorrectly() + { + // Arrange + var startTime = DateTime.UtcNow; + var endTime = startTime.AddSeconds(30); + + var result = new UpdateResult + { + StartTime = startTime, + EndTime = endTime + }; + + // Act + var duration = result.DurationMs; + + // Assert + Assert.InRange(duration, 29900, 30100); // Allow 100ms tolerance + } + + /// + /// Tests that StepLogs can be modified. + /// + [Fact] + public void StepLogs_CanBeModified() + { + // Arrange + var result = new UpdateResult(); + + // Act + result.StepLogs.Add("Step 1: Started"); + result.StepLogs.Add("Step 2: Validation"); + result.StepLogs.Add("Step 3: Completed"); + + // Assert + Assert.Equal(3, result.StepLogs.Count); + Assert.Contains("Step 1: Started", result.StepLogs); + Assert.Contains("Step 2: Validation", result.StepLogs); + Assert.Contains("Step 3: Completed", result.StepLogs); + } + + /// + /// Tests UpdateStatus enum values. + /// + [Fact] + public void UpdateStatus_HasExpectedValues() + { + // Assert + Assert.Equal(0, (int)UpdateStatus.NotStarted); + Assert.Equal(1, (int)UpdateStatus.Validating); + Assert.Equal(2, (int)UpdateStatus.BackingUp); + Assert.Equal(3, (int)UpdateStatus.Updating); + Assert.Equal(4, (int)UpdateStatus.Verifying); + Assert.Equal(5, (int)UpdateStatus.Succeeded); + Assert.Equal(6, (int)UpdateStatus.Failed); + Assert.Equal(7, (int)UpdateStatus.RolledBack); + } +} + +/// +/// Tests for ErrorInfo model class. +/// Validates error information structure. +/// +public class ErrorInfoTests +{ + /// + /// Tests that ErrorInfo can be instantiated. + /// + [Fact] + public void Constructor_CreatesInstance() + { + // Act + var errorInfo = new ErrorInfo(); + + // Assert + Assert.NotNull(errorInfo); + } + + /// + /// Tests that ErrorInfo properties can be set and retrieved. + /// + [Fact] + public void Properties_CanBeSetAndRetrieved() + { + // Arrange + var innerException = new InvalidOperationException("Inner exception"); + var errorInfo = new ErrorInfo + { + Code = "ERR001", + Type = ErrorType.InstallationFailed, + Message = "Installation failed", + Details = "Detailed error information", + StackTrace = "Stack trace here", + InnerException = innerException, + CanRetry = true, + SuggestedResolution = "Try again" + }; + + // Act & Assert + Assert.Equal("ERR001", errorInfo.Code); + Assert.Equal(ErrorType.InstallationFailed, errorInfo.Type); + Assert.Equal("Installation failed", errorInfo.Message); + Assert.Equal("Detailed error information", errorInfo.Details); + Assert.Equal("Stack trace here", errorInfo.StackTrace); + Assert.Equal(innerException, errorInfo.InnerException); + Assert.True(errorInfo.CanRetry); + Assert.Equal("Try again", errorInfo.SuggestedResolution); + } +} diff --git a/src/c#/DrivelutionTest/Utilities/CompatibilityCheckerTests.cs b/src/c#/DrivelutionTest/Utilities/CompatibilityCheckerTests.cs new file mode 100644 index 00000000..bfc10ab0 --- /dev/null +++ b/src/c#/DrivelutionTest/Utilities/CompatibilityCheckerTests.cs @@ -0,0 +1,335 @@ +using GeneralUpdate.Drivelution.Core.Utilities; +using GeneralUpdate.Drivelution.Abstractions.Models; + +namespace DrivelutionTest.Utilities; + +/// +/// Tests for CompatibilityChecker utility class. +/// Validates platform compatibility checking functionality. +/// +public class CompatibilityCheckerTests +{ + /// + /// Tests that GetCurrentOS returns a valid operating system name. + /// + [Fact] + public void GetCurrentOS_ReturnsValidOSName() + { + // Act + var os = CompatibilityChecker.GetCurrentOS(); + + // Assert + Assert.NotNull(os); + Assert.Contains(os, new[] { "Windows", "Linux", "MacOS", "Unknown" }); + } + + /// + /// Tests that GetCurrentArchitecture returns a valid architecture. + /// + [Fact] + public void GetCurrentArchitecture_ReturnsValidArchitecture() + { + // Act + var arch = CompatibilityChecker.GetCurrentArchitecture(); + + // Assert + Assert.NotNull(arch); + Assert.NotEmpty(arch); + // Common architectures: X64, X86, Arm, Arm64 + Assert.True(arch.Length > 0); + } + + /// + /// Tests that GetSystemVersion returns a valid version string. + /// + [Fact] + public void GetSystemVersion_ReturnsValidVersionString() + { + // Act + var version = CompatibilityChecker.GetSystemVersion(); + + // Assert + Assert.NotNull(version); + Assert.NotEmpty(version); + } + + /// + /// Tests that CheckCompatibility returns true for compatible driver. + /// + [Fact] + public void CheckCompatibility_WithCompatibleDriver_ReturnsTrue() + { + // Arrange + var currentOS = CompatibilityChecker.GetCurrentOS(); + var currentArch = CompatibilityChecker.GetCurrentArchitecture(); + + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = currentOS, + Architecture = currentArch, + FilePath = "/test/driver.sys" + }; + + // Act + var isCompatible = CompatibilityChecker.CheckCompatibility(driverInfo); + + // Assert + Assert.True(isCompatible); + } + + /// + /// Tests that CheckCompatibility returns false for incompatible OS. + /// + [Fact] + public void CheckCompatibility_WithIncompatibleOS_ReturnsFalse() + { + // Arrange + var currentOS = CompatibilityChecker.GetCurrentOS(); + var incompatibleOS = currentOS == "Windows" ? "Linux" : "Windows"; + + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = incompatibleOS, + Architecture = CompatibilityChecker.GetCurrentArchitecture(), + FilePath = "/test/driver.sys" + }; + + // Act + var isCompatible = CompatibilityChecker.CheckCompatibility(driverInfo); + + // Assert + Assert.False(isCompatible); + } + + /// + /// Tests that CheckCompatibility returns false for incompatible architecture. + /// + [Fact] + public void CheckCompatibility_WithIncompatibleArchitecture_ReturnsFalse() + { + // Arrange + var currentArch = CompatibilityChecker.GetCurrentArchitecture(); + var incompatibleArch = currentArch.Contains("64") ? "X86" : "X64"; + + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = CompatibilityChecker.GetCurrentOS(), + Architecture = incompatibleArch, + FilePath = "/test/driver.sys" + }; + + // Act + var isCompatible = CompatibilityChecker.CheckCompatibility(driverInfo); + + // Assert + Assert.False(isCompatible); + } + + /// + /// Tests that CheckCompatibility returns true when TargetOS is empty. + /// + [Fact] + public void CheckCompatibility_WithEmptyTargetOS_ReturnsTrue() + { + // Arrange + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = "", + Architecture = CompatibilityChecker.GetCurrentArchitecture(), + FilePath = "/test/driver.sys" + }; + + // Act + var isCompatible = CompatibilityChecker.CheckCompatibility(driverInfo); + + // Assert + Assert.True(isCompatible); + } + + /// + /// Tests that CheckCompatibility returns true when Architecture is empty. + /// + [Fact] + public void CheckCompatibility_WithEmptyArchitecture_ReturnsTrue() + { + // Arrange + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = CompatibilityChecker.GetCurrentOS(), + Architecture = "", + FilePath = "/test/driver.sys" + }; + + // Act + var isCompatible = CompatibilityChecker.CheckCompatibility(driverInfo); + + // Assert + Assert.True(isCompatible); + } + + /// + /// Tests that CheckCompatibility throws ArgumentNullException for null driver info. + /// + [Fact] + public void CheckCompatibility_WithNullDriverInfo_ThrowsArgumentNullException() + { + // Act & Assert + Assert.Throws(() => CompatibilityChecker.CheckCompatibility(null!)); + } + + /// + /// Tests that CheckCompatibilityAsync works correctly. + /// + [Fact] + public async Task CheckCompatibilityAsync_WithCompatibleDriver_ReturnsTrue() + { + // Arrange + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = CompatibilityChecker.GetCurrentOS(), + Architecture = CompatibilityChecker.GetCurrentArchitecture(), + FilePath = "/test/driver.sys" + }; + + // Act + var isCompatible = await CompatibilityChecker.CheckCompatibilityAsync(driverInfo); + + // Assert + Assert.True(isCompatible); + } + + /// + /// Tests that CheckCompatibilityAsync can be cancelled. + /// + [Fact] + public async Task CheckCompatibilityAsync_WithCancellation_ThrowsOperationCanceledException() + { + // Arrange + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = CompatibilityChecker.GetCurrentOS(), + Architecture = CompatibilityChecker.GetCurrentArchitecture(), + FilePath = "/test/driver.sys" + }; + var cts = new CancellationTokenSource(); + cts.Cancel(); + + // Act & Assert + await Assert.ThrowsAnyAsync( + () => CompatibilityChecker.CheckCompatibilityAsync(driverInfo, cts.Token)); + } + + /// + /// Tests that GetCompatibilityReport returns a complete report. + /// + [Fact] + public void GetCompatibilityReport_ReturnsCompleteReport() + { + // Arrange + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = CompatibilityChecker.GetCurrentOS(), + Architecture = CompatibilityChecker.GetCurrentArchitecture(), + FilePath = "/test/driver.sys" + }; + + // Act + var report = CompatibilityChecker.GetCompatibilityReport(driverInfo); + + // Assert + Assert.NotNull(report); + Assert.NotNull(report.CurrentOS); + Assert.NotNull(report.CurrentArchitecture); + Assert.NotNull(report.SystemVersion); + Assert.True(report.OSCompatible); + Assert.True(report.ArchitectureCompatible); + Assert.True(report.OverallCompatible); + } + + /// + /// Tests that GetCompatibilityReport shows incompatibility correctly. + /// + [Fact] + public void GetCompatibilityReport_WithIncompatibleDriver_ShowsIncompatibility() + { + // Arrange + var currentOS = CompatibilityChecker.GetCurrentOS(); + var incompatibleOS = currentOS == "Windows" ? "Linux" : "Windows"; + + var driverInfo = new DriverInfo + { + Name = "Test Driver", + Version = "1.0.0", + TargetOS = incompatibleOS, + Architecture = "InvalidArchitecture", + FilePath = "/test/driver.sys" + }; + + // Act + var report = CompatibilityChecker.GetCompatibilityReport(driverInfo); + + // Assert + Assert.NotNull(report); + Assert.False(report.OSCompatible); + Assert.False(report.ArchitectureCompatible); + Assert.False(report.OverallCompatible); + } + + /// + /// Tests that architecture normalization works correctly. + /// + [Fact] + public void CheckCompatibility_WithArchitectureAliases_RecognizesAliases() + { + // Arrange - Test common architecture aliases + var testCases = new[] + { + ("X64", "AMD64"), + ("X64", "x86_64"), + ("X86", "i386"), + ("ARM64", "AARCH64") + }; + + foreach (var (arch1, arch2) in testCases) + { + var driverInfo1 = new DriverInfo + { + Name = "Test Driver", + TargetOS = "", + Architecture = arch1, + FilePath = "/test/driver.sys" + }; + + var driverInfo2 = new DriverInfo + { + Name = "Test Driver", + TargetOS = "", + Architecture = arch2, + FilePath = "/test/driver.sys" + }; + + // Act - Both should be treated the same way + var result1 = CompatibilityChecker.CheckCompatibility(driverInfo1); + var result2 = CompatibilityChecker.CheckCompatibility(driverInfo2); + + // Assert - Results should be consistent (both true or both false) + Assert.Equal(result1, result2); + } + } +} diff --git a/src/c#/DrivelutionTest/Utilities/HashValidatorTests.cs b/src/c#/DrivelutionTest/Utilities/HashValidatorTests.cs new file mode 100644 index 00000000..ce7c6d40 --- /dev/null +++ b/src/c#/DrivelutionTest/Utilities/HashValidatorTests.cs @@ -0,0 +1,237 @@ +using GeneralUpdate.Drivelution.Core.Utilities; + +namespace DrivelutionTest.Utilities; + +/// +/// Tests for HashValidator utility class. +/// Validates file hash computation and validation functionality. +/// +public class HashValidatorTests : IDisposable +{ + private readonly string _testFilePath; + private readonly string _testContent = "Hello, World! This is test content for hash validation."; + + public HashValidatorTests() + { + // Create a temporary test file + _testFilePath = Path.Combine(Path.GetTempPath(), $"test_{Guid.NewGuid()}.txt"); + File.WriteAllText(_testFilePath, _testContent); + } + + /// + /// Cleanup temporary test files. + /// + public void Dispose() + { + if (File.Exists(_testFilePath)) + { + try + { + File.Delete(_testFilePath); + } + catch + { + // Ignore cleanup errors + } + } + } + + /// + /// Tests that ComputeHashAsync returns a valid SHA256 hash. + /// + [Fact] + public async Task ComputeHashAsync_WithSHA256_ReturnsValidHash() + { + // Act + var hash = await HashValidator.ComputeHashAsync(_testFilePath, "SHA256"); + + // Assert + Assert.NotNull(hash); + Assert.NotEmpty(hash); + Assert.Equal(64, hash.Length); // SHA256 hash is 64 hex characters + Assert.Matches("^[a-f0-9]+$", hash); // Only lowercase hex characters + } + + /// + /// Tests that ComputeHashAsync returns a valid MD5 hash. + /// + [Fact] + public async Task ComputeHashAsync_WithMD5_ReturnsValidHash() + { + // Act + var hash = await HashValidator.ComputeHashAsync(_testFilePath, "MD5"); + + // Assert + Assert.NotNull(hash); + Assert.NotEmpty(hash); + Assert.Equal(32, hash.Length); // MD5 hash is 32 hex characters + Assert.Matches("^[a-f0-9]+$", hash); + } + + /// + /// Tests that ComputeHashAsync throws FileNotFoundException for non-existent file. + /// + [Fact] + public async Task ComputeHashAsync_WithNonExistentFile_ThrowsFileNotFoundException() + { + // Arrange + var nonExistentFile = Path.Combine(Path.GetTempPath(), $"nonexistent_{Guid.NewGuid()}.txt"); + + // Act & Assert + await Assert.ThrowsAsync( + () => HashValidator.ComputeHashAsync(nonExistentFile)); + } + + /// + /// Tests that ComputeHashAsync throws ArgumentException for unsupported algorithm. + /// + [Fact] + public async Task ComputeHashAsync_WithUnsupportedAlgorithm_ThrowsArgumentException() + { + // Act & Assert + await Assert.ThrowsAsync( + () => HashValidator.ComputeHashAsync(_testFilePath, "UNSUPPORTED")); + } + + /// + /// Tests that ValidateHashAsync returns true for matching hash. + /// + [Fact] + public async Task ValidateHashAsync_WithMatchingHash_ReturnsTrue() + { + // Arrange + var expectedHash = await HashValidator.ComputeHashAsync(_testFilePath, "SHA256"); + + // Act + var isValid = await HashValidator.ValidateHashAsync(_testFilePath, expectedHash, "SHA256"); + + // Assert + Assert.True(isValid); + } + + /// + /// Tests that ValidateHashAsync returns false for non-matching hash. + /// + [Fact] + public async Task ValidateHashAsync_WithNonMatchingHash_ReturnsFalse() + { + // Arrange + var wrongHash = "0000000000000000000000000000000000000000000000000000000000000000"; + + // Act + var isValid = await HashValidator.ValidateHashAsync(_testFilePath, wrongHash, "SHA256"); + + // Assert + Assert.False(isValid); + } + + /// + /// Tests that ValidateHashAsync is case-insensitive. + /// + [Fact] + public async Task ValidateHashAsync_IsCaseInsensitive() + { + // Arrange + var expectedHash = await HashValidator.ComputeHashAsync(_testFilePath, "SHA256"); + var upperCaseHash = expectedHash.ToUpperInvariant(); + + // Act + var isValid = await HashValidator.ValidateHashAsync(_testFilePath, upperCaseHash, "SHA256"); + + // Assert + Assert.True(isValid); + } + + /// + /// Tests that ValidateHashAsync throws ArgumentException for null or empty hash. + /// + [Fact] + public async Task ValidateHashAsync_WithNullOrEmptyHash_ThrowsArgumentException() + { + // Act & Assert + await Assert.ThrowsAsync( + () => HashValidator.ValidateHashAsync(_testFilePath, "", "SHA256")); + + await Assert.ThrowsAsync( + () => HashValidator.ValidateHashAsync(_testFilePath, null!, "SHA256")); + } + + /// + /// Tests that ComputeStringHash returns a valid hash for string input. + /// + [Fact] + public void ComputeStringHash_WithValidString_ReturnsValidHash() + { + // Arrange + var input = "Test String"; + + // Act + var hash = HashValidator.ComputeStringHash(input, "SHA256"); + + // Assert + Assert.NotNull(hash); + Assert.NotEmpty(hash); + Assert.Equal(64, hash.Length); + } + + /// + /// Tests that ComputeStringHash returns consistent results. + /// + [Fact] + public void ComputeStringHash_WithSameInput_ReturnsConsistentHash() + { + // Arrange + var input = "Consistent Test"; + + // Act + var hash1 = HashValidator.ComputeStringHash(input, "SHA256"); + var hash2 = HashValidator.ComputeStringHash(input, "SHA256"); + + // Assert + Assert.Equal(hash1, hash2); + } + + /// + /// Tests that ComputeStringHash returns different hashes for different inputs. + /// + [Fact] + public void ComputeStringHash_WithDifferentInputs_ReturnsDifferentHashes() + { + // Arrange + var input1 = "Test 1"; + var input2 = "Test 2"; + + // Act + var hash1 = HashValidator.ComputeStringHash(input1, "SHA256"); + var hash2 = HashValidator.ComputeStringHash(input2, "SHA256"); + + // Assert + Assert.NotEqual(hash1, hash2); + } + + /// + /// Tests that ComputeStringHash throws ArgumentException for null or empty input. + /// + [Fact] + public void ComputeStringHash_WithNullOrEmptyInput_ThrowsArgumentException() + { + // Act & Assert + Assert.Throws(() => HashValidator.ComputeStringHash("")); + Assert.Throws(() => HashValidator.ComputeStringHash(null!)); + } + + /// + /// Tests that hash computation can be cancelled. + /// + [Fact] + public async Task ComputeHashAsync_WithCancellation_ThrowsOperationCanceledException() + { + // Arrange + var cts = new CancellationTokenSource(); + cts.Cancel(); + + // Act & Assert + await Assert.ThrowsAnyAsync( + () => HashValidator.ComputeHashAsync(_testFilePath, "SHA256", cts.Token)); + } +} diff --git a/src/c#/DrivelutionTest/Utilities/VersionComparerAndRestartHelperTests.cs b/src/c#/DrivelutionTest/Utilities/VersionComparerAndRestartHelperTests.cs new file mode 100644 index 00000000..04234777 --- /dev/null +++ b/src/c#/DrivelutionTest/Utilities/VersionComparerAndRestartHelperTests.cs @@ -0,0 +1,384 @@ +using GeneralUpdate.Drivelution.Core.Utilities; +using GeneralUpdate.Drivelution.Abstractions.Models; + +namespace DrivelutionTest.Utilities; + +/// +/// Tests for VersionComparer utility class. +/// Validates semantic versioning comparison functionality. +/// +public class VersionComparerTests +{ + /// + /// Tests that Compare returns 0 for equal versions. + /// + [Fact] + public void Compare_WithEqualVersions_ReturnsZero() + { + // Act + var result = VersionComparer.Compare("1.0.0", "1.0.0"); + + // Assert + Assert.Equal(0, result); + } + + /// + /// Tests that Compare returns 1 when first version is greater. + /// + [Fact] + public void Compare_WithGreaterFirstVersion_ReturnsOne() + { + // Act + var result = VersionComparer.Compare("2.0.0", "1.0.0"); + + // Assert + Assert.Equal(1, result); + } + + /// + /// Tests that Compare returns -1 when first version is less. + /// + [Fact] + public void Compare_WithLesserFirstVersion_ReturnsNegativeOne() + { + // Act + var result = VersionComparer.Compare("1.0.0", "2.0.0"); + + // Assert + Assert.Equal(-1, result); + } + + /// + /// Tests version comparison with minor version differences. + /// + [Fact] + public void Compare_WithMinorVersionDifference_ReturnsCorrectResult() + { + // Assert + Assert.True(VersionComparer.Compare("1.1.0", "1.0.0") > 0); + Assert.True(VersionComparer.Compare("1.0.0", "1.1.0") < 0); + } + + /// + /// Tests version comparison with patch version differences. + /// + [Fact] + public void Compare_WithPatchVersionDifference_ReturnsCorrectResult() + { + // Assert + Assert.True(VersionComparer.Compare("1.0.1", "1.0.0") > 0); + Assert.True(VersionComparer.Compare("1.0.0", "1.0.1") < 0); + } + + /// + /// Tests that version without prerelease is greater than version with prerelease. + /// + [Fact] + public void Compare_ReleaseVersionIsGreaterThanPrerelease() + { + // Act + var result = VersionComparer.Compare("1.0.0", "1.0.0-alpha"); + + // Assert + Assert.True(result > 0); + } + + /// + /// Tests prerelease version comparison. + /// + [Fact] + public void Compare_WithPrereleaseVersions_ComparesCorrectly() + { + // Assert + Assert.True(VersionComparer.Compare("1.0.0-beta", "1.0.0-alpha") > 0); + Assert.True(VersionComparer.Compare("1.0.0-alpha.2", "1.0.0-alpha.1") > 0); + } + + /// + /// Tests IsGreaterThan method. + /// + [Fact] + public void IsGreaterThan_WithGreaterVersion_ReturnsTrue() + { + // Act + var result = VersionComparer.IsGreaterThan("2.0.0", "1.0.0"); + + // Assert + Assert.True(result); + } + + /// + /// Tests IsGreaterThan method with lesser version. + /// + [Fact] + public void IsGreaterThan_WithLesserVersion_ReturnsFalse() + { + // Act + var result = VersionComparer.IsGreaterThan("1.0.0", "2.0.0"); + + // Assert + Assert.False(result); + } + + /// + /// Tests IsLessThan method. + /// + [Fact] + public void IsLessThan_WithLesserVersion_ReturnsTrue() + { + // Act + var result = VersionComparer.IsLessThan("1.0.0", "2.0.0"); + + // Assert + Assert.True(result); + } + + /// + /// Tests IsLessThan method with greater version. + /// + [Fact] + public void IsLessThan_WithGreaterVersion_ReturnsFalse() + { + // Act + var result = VersionComparer.IsLessThan("2.0.0", "1.0.0"); + + // Assert + Assert.False(result); + } + + /// + /// Tests IsEqual method. + /// + [Fact] + public void IsEqual_WithEqualVersions_ReturnsTrue() + { + // Act + var result = VersionComparer.IsEqual("1.0.0", "1.0.0"); + + // Assert + Assert.True(result); + } + + /// + /// Tests IsEqual method with different versions. + /// + [Fact] + public void IsEqual_WithDifferentVersions_ReturnsFalse() + { + // Act + var result = VersionComparer.IsEqual("1.0.0", "1.0.1"); + + // Assert + Assert.False(result); + } + + /// + /// Tests IsValidSemVer with valid versions. + /// + [Theory] + [InlineData("1.0.0")] + [InlineData("1.0.0-alpha")] + [InlineData("1.0.0-alpha.1")] + [InlineData("1.0.0+20130313144700")] + [InlineData("1.0.0-beta+exp.sha.5114f85")] + [InlineData("10.20.30")] + public void IsValidSemVer_WithValidVersions_ReturnsTrue(string version) + { + // Act + var result = VersionComparer.IsValidSemVer(version); + + // Assert + Assert.True(result); + } + + /// + /// Tests IsValidSemVer with invalid versions. + /// + [Theory] + [InlineData("")] + [InlineData(" ")] + [InlineData("1")] + [InlineData("1.0")] + [InlineData("1.0.0.0")] + [InlineData("v1.0.0")] + [InlineData("01.0.0")] + public void IsValidSemVer_WithInvalidVersions_ReturnsFalse(string version) + { + // Act + var result = VersionComparer.IsValidSemVer(version); + + // Assert + Assert.False(result); + } + + /// + /// Tests Compare throws ArgumentException for null or empty versions. + /// + [Fact] + public void Compare_WithNullOrEmptyVersion_ThrowsArgumentException() + { + // Act & Assert + Assert.Throws(() => VersionComparer.Compare("", "1.0.0")); + Assert.Throws(() => VersionComparer.Compare("1.0.0", "")); + Assert.Throws(() => VersionComparer.Compare(null!, "1.0.0")); + } + + /// + /// Tests Compare throws FormatException for invalid version format. + /// + [Fact] + public void Compare_WithInvalidFormat_ThrowsFormatException() + { + // Act & Assert + Assert.Throws(() => VersionComparer.Compare("invalid", "1.0.0")); + Assert.Throws(() => VersionComparer.Compare("1.0.0", "v1.0.0")); + } + + /// + /// Tests complex prerelease version comparison scenarios. + /// + [Fact] + public void Compare_WithComplexPrereleaseVersions_ComparesCorrectly() + { + // Arrange & Act & Assert + Assert.True(VersionComparer.Compare("1.0.0-rc.1", "1.0.0-beta.11") > 0); + Assert.True(VersionComparer.Compare("1.0.0-rc.1", "1.0.0-rc.0") > 0); + Assert.True(VersionComparer.Compare("1.0.0-alpha.beta", "1.0.0-alpha.1") > 0); // alphanumeric > numeric + Assert.True(VersionComparer.Compare("1.0.0-alpha", "1.0.0-alpha.1") < 0); // shorter < longer + } + + /// + /// Tests that build metadata is ignored in comparison. + /// + [Fact] + public void Compare_IgnoresBuildMetadata() + { + // Act + var result = VersionComparer.Compare("1.0.0+build1", "1.0.0+build2"); + + // Assert + Assert.Equal(0, result); + } + + /// + /// Tests version comparison with various real-world scenarios. + /// + [Theory] + [InlineData("1.0.0", "1.0.0", 0)] + [InlineData("2.0.0", "1.9.9", 1)] + [InlineData("1.0.0", "1.0.1", -1)] + [InlineData("1.1.0", "1.0.9", 1)] + [InlineData("1.0.0", "1.0.0-rc.1", 1)] + [InlineData("1.0.0-rc.2", "1.0.0-rc.1", 1)] + public void Compare_RealWorldScenarios_ReturnsExpectedResult(string version1, string version2, int expected) + { + // Act + var result = VersionComparer.Compare(version1, version2); + + // Assert + Assert.Equal(Math.Sign(expected), Math.Sign(result)); + } +} + +/// +/// Tests for RestartHelper utility class. +/// Validates restart handling functionality. +/// +public class RestartHelperTests +{ + /// + /// Tests that IsRestartRequired returns false for None mode. + /// + [Fact] + public void IsRestartRequired_WithNoneMode_ReturnsFalse() + { + // Act + var result = RestartHelper.IsRestartRequired(RestartMode.None); + + // Assert + Assert.False(result); + } + + /// + /// Tests that IsRestartRequired returns true for non-None modes. + /// + [Theory] + [InlineData(RestartMode.Prompt)] + [InlineData(RestartMode.Delayed)] + [InlineData(RestartMode.Immediate)] + public void IsRestartRequired_WithRestartModes_ReturnsTrue(RestartMode mode) + { + // Act + var result = RestartHelper.IsRestartRequired(mode); + + // Assert + Assert.True(result); + } + + /// + /// Tests that HandleRestartAsync with None mode returns true. + /// + [Fact] + public async Task HandleRestartAsync_WithNoneMode_ReturnsTrue() + { + // Act + var result = await RestartHelper.HandleRestartAsync(RestartMode.None); + + // Assert + Assert.True(result); + } + + /// + /// Tests that HandleRestartAsync with Prompt mode returns false (no user interaction in tests). + /// + [Fact] + public async Task HandleRestartAsync_WithPromptMode_ReturnsFalse() + { + // Act + var result = await RestartHelper.HandleRestartAsync(RestartMode.Prompt); + + // Assert + Assert.False(result); // Prompt returns false as there's no user interaction + } + + /// + /// Tests that PromptUserForRestart displays message and returns false. + /// + [Fact] + public void PromptUserForRestart_DisplaysMessage_ReturnsFalse() + { + // Act + var result = RestartHelper.PromptUserForRestart("Test message"); + + // Assert + Assert.False(result); + } + + /// + /// Tests that PromptUserForRestart with empty message uses default message. + /// + [Fact] + public void PromptUserForRestart_WithEmptyMessage_UsesDefaultMessage() + { + // Act + var result = RestartHelper.PromptUserForRestart(""); + + // Assert + Assert.False(result); + } + + /// + /// Tests that RestartHelper methods are callable without throwing exceptions + /// in non-privileged test environment (actual restart will fail due to permissions). + /// Note: We cannot actually restart the system during tests. + /// + [Fact] + public void RestartHelper_PublicMethods_AreCallable() + { + // This test documents that the RestartHelper class and its public methods exist + // and are callable. Actual restart functionality cannot be safely tested in unit tests. + // Act & Assert + Assert.True(RestartHelper.IsRestartRequired(RestartMode.None) == false); + Assert.True(RestartHelper.IsRestartRequired(RestartMode.Prompt) == true); + } +} From 9573e676634dce7c525c1b5d2d89b3ae4ad85862 Mon Sep 17 00:00:00 2001 From: Copilot <198982749+Copilot@users.noreply.github.com> Date: Mon, 9 Feb 2026 01:18:18 +0800 Subject: [PATCH 4/5] Rename DriverUpdate to Drivelution across codebase (#141) * Initial plan * Replace all instances of DriverUpdate with Drivelution Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> * Update error code prefixes from DU_ to DR_ Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> --- doc/GeneralUpdate.Drivelution.md | 22 +++++----- .../Core/DriverUpdaterFactoryTests.cs | 40 +++++++++--------- .../GeneralDrivelutionTests.cs | 4 +- .../Configuration/DriverUpdateOptions.cs | 4 +- .../Exceptions/DriverUpdateExceptions.cs | 42 +++++++++---------- .../Core/DriverUpdaterFactory.cs | 6 +-- .../Core/Logging/LoggerConfigurator.cs | 6 +-- .../GeneralDrivelution.cs | 14 +++---- .../WindowsGeneralDrivelution.cs | 2 +- 9 files changed, 70 insertions(+), 70 deletions(-) diff --git a/doc/GeneralUpdate.Drivelution.md b/doc/GeneralUpdate.Drivelution.md index 6dabb064..7952a7e0 100644 --- a/doc/GeneralUpdate.Drivelution.md +++ b/doc/GeneralUpdate.Drivelution.md @@ -73,10 +73,10 @@ using GeneralUpdate.Drivelution.Abstractions.Configuration; using GeneralUpdate.Drivelution.Abstractions.Models; // Configure options -var options = new DriverUpdateOptions +var options = new DrivelutionOptions { LogLevel = "Debug", - LogFilePath = "./Logs/driver-update-.log", + LogFilePath = "./Logs/drivelution-.log", EnableConsoleLogging = true, EnableFileLogging = true, DefaultBackupPath = "./Backups", @@ -272,7 +272,7 @@ var driverInfo = new DriverInfo #### GPG Signature Validation ```csharp // Linux drivers can be validated using GPG signatures -var options = new DriverUpdateOptions +var options = new DrivelutionOptions { TrustedGpgKeys = new List { @@ -531,10 +531,10 @@ var updater = GeneralDrivelution.Create(); ### Custom Logging Configuration ```csharp -var options = new DriverUpdateOptions +var options = new DrivelutionOptions { LogLevel = "Debug", // Verbose logging - LogFilePath = "./Logs/driver-update-.log", // Rolling file logs + LogFilePath = "./Logs/drivelution-.log", // Rolling file logs EnableConsoleLogging = true, // Console output EnableFileLogging = true // File output }; @@ -707,7 +707,7 @@ catch (OperationCanceledException) ### 5. Log Everything ```csharp -var options = new DriverUpdateOptions +var options = new DrivelutionOptions { LogLevel = "Info", // Use Info level in production EnableFileLogging = true, // Keep file logs for auditing @@ -718,7 +718,7 @@ var options = new DriverUpdateOptions ### 6. Clean Up Old Backups ```csharp -var options = new DriverUpdateOptions +var options = new DrivelutionOptions { AutoCleanupBackups = true, // Enable automatic cleanup BackupsToKeep = 5 // Keep last 5 backups @@ -751,7 +751,7 @@ var strategy = new UpdateStrategy ```csharp public async Task PerformSilentUpdateAsync(DriverInfo driverInfo) { - var options = new DriverUpdateOptions + var options = new DrivelutionOptions { EnableConsoleLogging = false, // No console output EnableFileLogging = true, // Log to file @@ -919,7 +919,7 @@ sudo ./YourApp **Solution**: ```csharp // Enable detailed logging to identify the specific validation failure -var options = new DriverUpdateOptions { LogLevel = "Debug" }; +var options = new DrivelutionOptions { LogLevel = "Debug" }; var updater = GeneralDrivelution.Create(options); // Try validation separately @@ -1060,10 +1060,10 @@ var strategy = new UpdateStrategy ```csharp // Create updater with default options -IGeneralDrivelution Create(DriverUpdateOptions? options = null) +IGeneralDrivelution Create(DrivelutionOptions? options = null) // Create updater with custom logger -IGeneralDrivelution Create(ILogger logger, DriverUpdateOptions? options = null) +IGeneralDrivelution Create(ILogger logger, DrivelutionOptions? options = null) // Quick update with default settings Task QuickUpdateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default) diff --git a/src/c#/DrivelutionTest/Core/DriverUpdaterFactoryTests.cs b/src/c#/DrivelutionTest/Core/DriverUpdaterFactoryTests.cs index 75feab57..eecd821c 100644 --- a/src/c#/DrivelutionTest/Core/DriverUpdaterFactoryTests.cs +++ b/src/c#/DrivelutionTest/Core/DriverUpdaterFactoryTests.cs @@ -7,10 +7,10 @@ namespace DrivelutionTest.Core; /// -/// Tests for DriverUpdaterFactory class. +/// Tests for DrivelutionFactory class. /// Validates platform detection, factory creation, and platform-specific implementations. /// -public class DriverUpdaterFactoryTests +public class DrivelutionFactoryTests { /// /// Tests that Create method returns a non-null instance. @@ -19,7 +19,7 @@ public class DriverUpdaterFactoryTests public void Create_WithoutParameters_ReturnsNonNullInstance() { // Arrange & Act - var updater = DriverUpdaterFactory.Create(); + var updater = DrivelutionFactory.Create(); // Assert Assert.NotNull(updater); @@ -39,7 +39,7 @@ public void Create_WithCustomLogger_ReturnsInstance() .CreateLogger(); // Act - var updater = DriverUpdaterFactory.Create(logger); + var updater = DrivelutionFactory.Create(logger); // Assert Assert.NotNull(updater); @@ -53,14 +53,14 @@ public void Create_WithCustomLogger_ReturnsInstance() public void Create_WithCustomOptions_ReturnsInstance() { // Arrange - var options = new DriverUpdateOptions + var options = new DrivelutionOptions { LogLevel = "Debug", LogFilePath = "./logs/test.log" }; // Act - var updater = DriverUpdaterFactory.Create(null, options); + var updater = DrivelutionFactory.Create(null, options); // Assert Assert.NotNull(updater); @@ -73,7 +73,7 @@ public void Create_WithCustomOptions_ReturnsInstance() public void GetCurrentPlatform_ReturnsValidPlatformName() { // Act - var platform = DriverUpdaterFactory.GetCurrentPlatform(); + var platform = DrivelutionFactory.GetCurrentPlatform(); // Assert Assert.NotNull(platform); @@ -87,11 +87,11 @@ public void GetCurrentPlatform_ReturnsValidPlatformName() public void IsPlatformSupported_ReturnsBooleanValue() { // Act - var isSupported = DriverUpdaterFactory.IsPlatformSupported(); + var isSupported = DrivelutionFactory.IsPlatformSupported(); // Assert // Windows and Linux should be supported - Assert.True(isSupported || DriverUpdaterFactory.GetCurrentPlatform() == "MacOS" || DriverUpdaterFactory.GetCurrentPlatform() == "Unknown"); + Assert.True(isSupported || DrivelutionFactory.GetCurrentPlatform() == "MacOS" || DrivelutionFactory.GetCurrentPlatform() == "Unknown"); } /// @@ -101,14 +101,14 @@ public void IsPlatformSupported_ReturnsBooleanValue() public void CreateValidator_WithoutLogger_ReturnsNonNullInstance() { // Skip on MacOS and Unknown platforms - var platform = DriverUpdaterFactory.GetCurrentPlatform(); + var platform = DrivelutionFactory.GetCurrentPlatform(); if (platform == "MacOS" || platform == "Unknown") { return; } // Act - var validator = DriverUpdaterFactory.CreateValidator(); + var validator = DrivelutionFactory.CreateValidator(); // Assert Assert.NotNull(validator); @@ -122,14 +122,14 @@ public void CreateValidator_WithoutLogger_ReturnsNonNullInstance() public void CreateBackup_WithoutLogger_ReturnsNonNullInstance() { // Skip on MacOS and Unknown platforms - var platform = DriverUpdaterFactory.GetCurrentPlatform(); + var platform = DrivelutionFactory.GetCurrentPlatform(); if (platform == "MacOS" || platform == "Unknown") { return; } // Act - var backup = DriverUpdaterFactory.CreateBackup(); + var backup = DrivelutionFactory.CreateBackup(); // Assert Assert.NotNull(backup); @@ -143,7 +143,7 @@ public void CreateBackup_WithoutLogger_ReturnsNonNullInstance() public void CreateValidator_WithCustomLogger_ReturnsInstance() { // Skip on MacOS and Unknown platforms - var platform = DriverUpdaterFactory.GetCurrentPlatform(); + var platform = DrivelutionFactory.GetCurrentPlatform(); if (platform == "MacOS" || platform == "Unknown") { return; @@ -156,7 +156,7 @@ public void CreateValidator_WithCustomLogger_ReturnsInstance() .CreateLogger(); // Act - var validator = DriverUpdaterFactory.CreateValidator(logger); + var validator = DrivelutionFactory.CreateValidator(logger); // Assert Assert.NotNull(validator); @@ -169,7 +169,7 @@ public void CreateValidator_WithCustomLogger_ReturnsInstance() public void CreateBackup_WithCustomLogger_ReturnsInstance() { // Skip on MacOS and Unknown platforms - var platform = DriverUpdaterFactory.GetCurrentPlatform(); + var platform = DrivelutionFactory.GetCurrentPlatform(); if (platform == "MacOS" || platform == "Unknown") { return; @@ -182,7 +182,7 @@ public void CreateBackup_WithCustomLogger_ReturnsInstance() .CreateLogger(); // Act - var backup = DriverUpdaterFactory.CreateBackup(logger); + var backup = DrivelutionFactory.CreateBackup(logger); // Assert Assert.NotNull(backup); @@ -196,17 +196,17 @@ public void CreateBackup_WithCustomLogger_ReturnsInstance() public void Create_OnSupportedPlatform_DoesNotThrow() { // Skip on MacOS as it's not yet implemented - var platform = DriverUpdaterFactory.GetCurrentPlatform(); + var platform = DrivelutionFactory.GetCurrentPlatform(); if (platform == "MacOS") { // MacOS should throw PlatformNotSupportedException - Assert.Throws(() => DriverUpdaterFactory.Create()); + Assert.Throws(() => DrivelutionFactory.Create()); return; } // Act & Assert - should not throw on Windows/Linux - var exception = Record.Exception(() => DriverUpdaterFactory.Create()); + var exception = Record.Exception(() => DrivelutionFactory.Create()); Assert.Null(exception); } } diff --git a/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs b/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs index c7460e4f..cd22a06d 100644 --- a/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs +++ b/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs @@ -31,7 +31,7 @@ public void Create_WithoutParameters_ReturnsNonNullInstance() public void Create_WithOptions_ReturnsNonNullInstance() { // Arrange - var options = new DriverUpdateOptions + var options = new DrivelutionOptions { LogLevel = "Information", LogFilePath = "./logs/test.log" @@ -74,7 +74,7 @@ public void Create_WithCustomLoggerAndOptions_ReturnsInstance() .MinimumLevel.Debug() .WriteTo.Console() .CreateLogger(); - var options = new DriverUpdateOptions + var options = new DrivelutionOptions { LogLevel = "Debug" }; diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Configuration/DriverUpdateOptions.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Configuration/DriverUpdateOptions.cs index 0258ec1d..b450a267 100644 --- a/src/c#/GeneralUpdate.Drivelution/Abstractions/Configuration/DriverUpdateOptions.cs +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/Configuration/DriverUpdateOptions.cs @@ -4,7 +4,7 @@ namespace GeneralUpdate.Drivelution.Abstractions.Configuration; /// 驱动更新配置选项 /// Driver update configuration options /// -public class DriverUpdateOptions +public class DrivelutionOptions { /// /// 默认备份路径 @@ -22,7 +22,7 @@ public class DriverUpdateOptions /// 日志文件路径 /// Log file path /// - public string LogFilePath { get; set; } = "./Logs/driver-update-.log"; + public string LogFilePath { get; set; } = "./Logs/drivelution-.log"; /// /// 是否启用控制台日志 diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Exceptions/DriverUpdateExceptions.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Exceptions/DriverUpdateExceptions.cs index ee1f76bf..6205b84c 100644 --- a/src/c#/GeneralUpdate.Drivelution/Abstractions/Exceptions/DriverUpdateExceptions.cs +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/Exceptions/DriverUpdateExceptions.cs @@ -4,19 +4,19 @@ namespace GeneralUpdate.Drivelution.Abstractions.Exceptions; /// 驱动更新基础异常 /// Base exception for driver update /// -public class DriverUpdateException : Exception +public class DrivelutionException : Exception { public string ErrorCode { get; set; } public bool CanRetry { get; set; } - public DriverUpdateException(string message, string errorCode = "DU_UNKNOWN", bool canRetry = false) + public DrivelutionException(string message, string errorCode = "DR_UNKNOWN", bool canRetry = false) : base(message) { ErrorCode = errorCode; CanRetry = canRetry; } - public DriverUpdateException(string message, Exception innerException, string errorCode = "DU_UNKNOWN", bool canRetry = false) + public DrivelutionException(string message, Exception innerException, string errorCode = "DR_UNKNOWN", bool canRetry = false) : base(message, innerException) { ErrorCode = errorCode; @@ -28,15 +28,15 @@ public DriverUpdateException(string message, Exception innerException, string er /// 权限异常 /// Permission exception /// -public class DriverPermissionException : DriverUpdateException +public class DriverPermissionException : DrivelutionException { public DriverPermissionException(string message) - : base(message, "DU_PERMISSION_DENIED", false) + : base(message, "DR_PERMISSION_DENIED", false) { } public DriverPermissionException(string message, Exception innerException) - : base(message, innerException, "DU_PERMISSION_DENIED", false) + : base(message, innerException, "DR_PERMISSION_DENIED", false) { } } @@ -45,18 +45,18 @@ public DriverPermissionException(string message, Exception innerException) /// 校验失败异常 /// Validation failed exception /// -public class DriverValidationException : DriverUpdateException +public class DriverValidationException : DrivelutionException { public string ValidationType { get; set; } public DriverValidationException(string message, string validationType) - : base(message, "DU_VALIDATION_FAILED", false) + : base(message, "DR_VALIDATION_FAILED", false) { ValidationType = validationType; } public DriverValidationException(string message, string validationType, Exception innerException) - : base(message, innerException, "DU_VALIDATION_FAILED", false) + : base(message, innerException, "DR_VALIDATION_FAILED", false) { ValidationType = validationType; } @@ -66,15 +66,15 @@ public DriverValidationException(string message, string validationType, Exceptio /// 安装失败异常 /// Installation failed exception /// -public class DriverInstallationException : DriverUpdateException +public class DriverInstallationException : DrivelutionException { public DriverInstallationException(string message, bool canRetry = true) - : base(message, "DU_INSTALLATION_FAILED", canRetry) + : base(message, "DR_INSTALLATION_FAILED", canRetry) { } public DriverInstallationException(string message, Exception innerException, bool canRetry = true) - : base(message, innerException, "DU_INSTALLATION_FAILED", canRetry) + : base(message, innerException, "DR_INSTALLATION_FAILED", canRetry) { } } @@ -83,15 +83,15 @@ public DriverInstallationException(string message, Exception innerException, boo /// 备份失败异常 /// Backup failed exception /// -public class DriverBackupException : DriverUpdateException +public class DriverBackupException : DrivelutionException { public DriverBackupException(string message) - : base(message, "DU_BACKUP_FAILED", true) + : base(message, "DR_BACKUP_FAILED", true) { } public DriverBackupException(string message, Exception innerException) - : base(message, innerException, "DU_BACKUP_FAILED", true) + : base(message, innerException, "DR_BACKUP_FAILED", true) { } } @@ -100,15 +100,15 @@ public DriverBackupException(string message, Exception innerException) /// 回滚失败异常 /// Rollback failed exception /// -public class DriverRollbackException : DriverUpdateException +public class DriverRollbackException : DrivelutionException { public DriverRollbackException(string message) - : base(message, "DU_ROLLBACK_FAILED", false) + : base(message, "DR_ROLLBACK_FAILED", false) { } public DriverRollbackException(string message, Exception innerException) - : base(message, innerException, "DU_ROLLBACK_FAILED", false) + : base(message, innerException, "DR_ROLLBACK_FAILED", false) { } } @@ -117,15 +117,15 @@ public DriverRollbackException(string message, Exception innerException) /// 兼容性异常 /// Compatibility exception /// -public class DriverCompatibilityException : DriverUpdateException +public class DriverCompatibilityException : DrivelutionException { public DriverCompatibilityException(string message) - : base(message, "DU_COMPATIBILITY_FAILED", false) + : base(message, "DR_COMPATIBILITY_FAILED", false) { } public DriverCompatibilityException(string message, Exception innerException) - : base(message, innerException, "DU_COMPATIBILITY_FAILED", false) + : base(message, innerException, "DR_COMPATIBILITY_FAILED", false) { } } diff --git a/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs b/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs index 4794c717..10a2e4af 100644 --- a/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs +++ b/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs @@ -12,7 +12,7 @@ namespace GeneralUpdate.Drivelution.Core; /// 驱动更新器工厂类 - 自动检测平台并创建相应的实现 /// Driver updater factory - Automatically detects platform and creates appropriate implementation /// -public static class DriverUpdaterFactory +public static class DrivelutionFactory { /// /// 创建适合当前平台的驱动更新器 @@ -22,7 +22,7 @@ public static class DriverUpdaterFactory /// 配置选项（可选）/ Configuration options (optional) /// 平台特定的驱动更新器实现 / Platform-specific driver updater implementation /// 当前平台不支持时抛出 / Thrown when current platform is not supported - public static IGeneralDrivelution Create(ILogger? logger = null, DriverUpdateOptions? options = null) + public static IGeneralDrivelution Create(ILogger? logger = null, DrivelutionOptions? options = null) { // Use default logger if not provided logger ??= CreateDefaultLogger(options); @@ -149,7 +149,7 @@ public static bool IsPlatformSupported() /// 创建默认日志记录器 /// Creates a default logger /// - private static ILogger CreateDefaultLogger(DriverUpdateOptions? options = null) + private static ILogger CreateDefaultLogger(DrivelutionOptions? options = null) { if (options != null) { diff --git a/src/c#/GeneralUpdate.Drivelution/Core/Logging/LoggerConfigurator.cs b/src/c#/GeneralUpdate.Drivelution/Core/Logging/LoggerConfigurator.cs index 9bf76232..5a488595 100644 --- a/src/c#/GeneralUpdate.Drivelution/Core/Logging/LoggerConfigurator.cs +++ b/src/c#/GeneralUpdate.Drivelution/Core/Logging/LoggerConfigurator.cs @@ -16,7 +16,7 @@ public static class LoggerConfigurator /// /// 驱动更新配置选项 / Driver update configuration options /// 配置好的日志器 / Configured logger - public static ILogger ConfigureLogger(DriverUpdateOptions options) + public static ILogger ConfigureLogger(DrivelutionOptions options) { if (options == null) { @@ -40,7 +40,7 @@ public static ILogger ConfigureLogger(DriverUpdateOptions options) if (options.EnableFileLogging) { var logPath = string.IsNullOrWhiteSpace(options.LogFilePath) - ? "./Logs/driver-update-.log" + ? "./Logs/drivelution-.log" : options.LogFilePath; loggerConfig.WriteTo.File( @@ -88,7 +88,7 @@ public static ILogger CreateDefaultLogger() .WriteTo.Console( outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}") .WriteTo.File( - "./Logs/driver-update-.log", + "./Logs/drivelution-.log", rollingInterval: RollingInterval.Day, outputTemplate: "[{Timestamp:yyyy-MM-dd HH:mm:ss.fff} {Level:u3}] {Message:lj}{NewLine}{Exception}", retainedFileCountLimit: 30) diff --git a/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs index 61380646..fd2dd2df 100644 --- a/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs +++ b/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs @@ -21,7 +21,7 @@ namespace GeneralUpdate.Drivelution; /// /// // 带配置使用 /// // With configuration -/// var options = new DriverUpdateOptions { LogLevel = "Info" }; +/// var options = new DrivelutionOptions { LogLevel = "Info" }; /// var updater = GeneralDrivelution.Create(options); /// var result = await updater.UpdateAsync(driverInfo, strategy); /// @@ -35,13 +35,13 @@ public static class GeneralDrivelution /// 配置选项（可选）/ Configuration options (optional) /// 适配当前平台的驱动更新器 / Platform-adapted driver updater /// 当前平台不支持时抛出 / Thrown when platform is not supported - public static IGeneralDrivelution Create(DriverUpdateOptions? options = null) + public static IGeneralDrivelution Create(DrivelutionOptions? options = null) { var logger = options != null ? LoggerConfigurator.ConfigureLogger(options) : LoggerConfigurator.CreateDefaultLogger(); - return Core.DriverUpdaterFactory.Create(logger, options); + return Core.DrivelutionFactory.Create(logger, options); } /// @@ -51,9 +51,9 @@ public static IGeneralDrivelution Create(DriverUpdateOptions? options = null) /// 自定义日志记录器 / Custom logger /// 配置选项（可选）/ Configuration options (optional) /// 适配当前平台的驱动更新器 / Platform-adapted driver updater - public static IGeneralDrivelution Create(ILogger logger, DriverUpdateOptions? options = null) + public static IGeneralDrivelution Create(ILogger logger, DrivelutionOptions? options = null) { - return Core.DriverUpdaterFactory.Create(logger, options); + return Core.DrivelutionFactory.Create(logger, options); } /// @@ -119,8 +119,8 @@ public static PlatformInfo GetPlatformInfo() { return new PlatformInfo { - Platform = Core.DriverUpdaterFactory.GetCurrentPlatform(), - IsSupported = Core.DriverUpdaterFactory.IsPlatformSupported(), + Platform = Core.DrivelutionFactory.GetCurrentPlatform(), + IsSupported = Core.DrivelutionFactory.IsPlatformSupported(), OperatingSystem = CompatibilityChecker.GetCurrentOS(), Architecture = CompatibilityChecker.GetCurrentArchitecture(), SystemVersion = CompatibilityChecker.GetSystemVersion() diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs index 56a54d4a..0e8ff2be 100644 --- a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs +++ b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs @@ -434,7 +434,7 @@ private ErrorInfo CreateErrorInfo(Exception ex, ErrorType type, bool canRetry) { return new ErrorInfo { - Code = ex is DriverUpdateException dex ? dex.ErrorCode : "DU_UNKNOWN", + Code = ex is DrivelutionException dex ? dex.ErrorCode : "DR_UNKNOWN", Type = type, Message = ex.Message, Details = ex.ToString(), From f443f1f2ae97fc1224a1315a65e416cf24a6642c Mon Sep 17 00:00:00 2001 From: Copilot <198982749+Copilot@users.noreply.github.com> Date: Mon, 9 Feb 2026 17:51:14 +0800 Subject: [PATCH 5/5] Add GetDriversFromDirectoryAsync for local driver discovery (#142) * Initial plan * Add GetDriversFromDirectoryAsync method to read driver information from local directory Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> * Add tests for GetDriversFromDirectoryAsync method Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> * Fix security issues: prevent command injection and improve certificate parsing Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> * Translate all Chinese annotations to English Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: JusterZhu <11714536+JusterZhu@users.noreply.github.com> --- .../GeneralDrivelutionTests.cs | 181 +++++++++++++ .../Abstractions/IGeneralDrivelution.cs | 42 +-- .../GeneralDrivelution.cs | 73 +++--- .../Implementation/LinuxGeneralDrivelution.cs | 239 ++++++++++++++++++ .../Implementation/MacOsGeneralDrivelution.cs | 10 + .../WindowsGeneralDrivelution.cs | 194 ++++++++++++++ 6 files changed, 686 insertions(+), 53 deletions(-) diff --git a/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs b/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs index cd22a06d..87973a42 100644 --- a/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs +++ b/src/c#/DrivelutionTest/GeneralDrivelutionTests.cs @@ -327,4 +327,185 @@ public void GetPlatformInfo_ReportsCorrectSupportStatus() Assert.False(platformInfo.IsSupported); // MacOS not yet implemented } } + + /// + /// Tests that GetDriversFromDirectoryAsync returns empty list for non-existent directory. + /// + [Fact] + public async Task GetDriversFromDirectoryAsync_WithNonExistentDirectory_ReturnsEmptyList() + { + // Arrange + var nonExistentPath = Path.Combine(Path.GetTempPath(), $"nonexistent_{Guid.NewGuid()}"); + + // Act + var result = await GeneralDrivelution.GetDriversFromDirectoryAsync(nonExistentPath); + + // Assert + Assert.NotNull(result); + Assert.Empty(result); + } + + /// + /// Tests that GetDriversFromDirectoryAsync returns empty list for empty directory. + /// + [Fact] + public async Task GetDriversFromDirectoryAsync_WithEmptyDirectory_ReturnsEmptyList() + { + // Arrange + var emptyDir = Path.Combine(Path.GetTempPath(), $"empty_{Guid.NewGuid()}"); + Directory.CreateDirectory(emptyDir); + + try + { + // Act + var result = await GeneralDrivelution.GetDriversFromDirectoryAsync(emptyDir); + + // Assert + Assert.NotNull(result); + Assert.Empty(result); + } + finally + { + if (Directory.Exists(emptyDir)) + { + Directory.Delete(emptyDir, true); + } + } + } + + /// + /// Tests that GetDriversFromDirectoryAsync discovers driver files in directory. + /// + [Fact] + public async Task GetDriversFromDirectoryAsync_WithDriverFiles_ReturnsDriverInfoList() + { + // Arrange + var testDir = Path.Combine(Path.GetTempPath(), $"drivers_{Guid.NewGuid()}"); + Directory.CreateDirectory(testDir); + + try + { + // Create test driver files based on platform + var platformInfo = GeneralDrivelution.GetPlatformInfo(); + var testFiles = new List(); + + if (platformInfo.Platform == "Windows") + { + // Create mock .inf file + var infFile = Path.Combine(testDir, "test_driver.inf"); + File.WriteAllText(infFile, @" +[Version] +Signature=""$Windows NT$"" +DriverVer=01/15/2024,1.0.0.0 + +[DriverInfo] +DriverDesc=""Test Driver"" +"); + testFiles.Add(infFile); + } + else if (platformInfo.Platform == "Linux") + { + // Create mock .ko file + var koFile = Path.Combine(testDir, "test_driver.ko"); + File.WriteAllText(koFile, "Mock kernel module content"); + testFiles.Add(koFile); + } + + // Act + var result = await GeneralDrivelution.GetDriversFromDirectoryAsync(testDir); + + // Assert + Assert.NotNull(result); + + // Should find at least one driver if platform is supported + if (platformInfo.IsSupported && testFiles.Any()) + { + Assert.NotEmpty(result); + + // Check that driver info has expected properties + var driver = result.First(); + Assert.NotNull(driver.Name); + Assert.NotEmpty(driver.Name); + Assert.NotNull(driver.FilePath); + Assert.NotEmpty(driver.FilePath); + Assert.NotNull(driver.Version); + Assert.NotEmpty(driver.Version); + Assert.NotNull(driver.Hash); + Assert.NotEmpty(driver.Hash); + } + } + finally + { + if (Directory.Exists(testDir)) + { + Directory.Delete(testDir, true); + } + } + } + + /// + /// Tests that GetDriversFromDirectoryAsync with search pattern filters correctly. + /// + [Fact] + public async Task GetDriversFromDirectoryAsync_WithSearchPattern_FiltersCorrectly() + { + // Arrange + var testDir = Path.Combine(Path.GetTempPath(), $"drivers_{Guid.NewGuid()}"); + Directory.CreateDirectory(testDir); + + try + { + // Create different types of files + var infFile = Path.Combine(testDir, "driver1.inf"); + var txtFile = Path.Combine(testDir, "readme.txt"); + File.WriteAllText(infFile, "INF content"); + File.WriteAllText(txtFile, "Text content"); + + // Act + var result = await GeneralDrivelution.GetDriversFromDirectoryAsync(testDir, "*.inf"); + + // Assert + Assert.NotNull(result); + + // Should only find .inf files + // The count depends on whether the platform supports parsing .inf files + } + finally + { + if (Directory.Exists(testDir)) + { + Directory.Delete(testDir, true); + } + } + } + + /// + /// Tests that GetDriversFromDirectoryAsync handles cancellation. + /// + [Fact] + public async Task GetDriversFromDirectoryAsync_WithCancellation_HandlesCancellation() + { + // Arrange + var testDir = Path.Combine(Path.GetTempPath(), $"drivers_{Guid.NewGuid()}"); + Directory.CreateDirectory(testDir); + + try + { + var cts = new CancellationTokenSource(); + cts.Cancel(); + + // Act + var result = await GeneralDrivelution.GetDriversFromDirectoryAsync(testDir, null, cts.Token); + + // Assert - Should complete without throwing or return empty list + Assert.NotNull(result); + } + finally + { + if (Directory.Exists(testDir)) + { + Directory.Delete(testDir, true); + } + } + } } diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/IGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/IGeneralDrivelution.cs index e43aa145..093e0360 100644 --- a/src/c#/GeneralUpdate.Drivelution/Abstractions/IGeneralDrivelution.cs +++ b/src/c#/GeneralUpdate.Drivelution/Abstractions/IGeneralDrivelution.cs @@ -4,19 +4,17 @@ namespace GeneralUpdate.Drivelution.Abstractions; /// -/// 驱动更新器核心接口 /// Core interface for driver updater /// public interface IGeneralDrivelution { /// - /// 异步更新驱动 /// Updates driver asynchronously /// - /// 驱动信息 / Driver information - /// 更新策略 / Update strategy - /// 取消令牌 / Cancellation token - /// 更新结果 / Update result + /// Driver information + /// Update strategy + /// Cancellation token + /// Update result /// /// Note: Update process may include signature validation that requires reflection on some platforms. /// @@ -25,12 +23,11 @@ public interface IGeneralDrivelution Task UpdateAsync(DriverInfo driverInfo, UpdateStrategy strategy, CancellationToken cancellationToken = default); /// - /// 异步验证驱动 /// Validates driver asynchronously /// - /// 驱动信息 / Driver information - /// 取消令牌 / Cancellation token - /// 验证是否通过 / Validation result + /// Driver information + /// Cancellation token + /// Validation result /// /// Note: Includes signature validation that may require reflection on some platforms. /// @@ -39,21 +36,28 @@ public interface IGeneralDrivelution Task ValidateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default); /// - /// 异步备份驱动 /// Backs up driver asynchronously /// - /// 驱动信息 / Driver information - /// 备份路径 / Backup path - /// 取消令牌 / Cancellation token - /// 备份结果 / Backup result + /// Driver information + /// Backup path + /// Cancellation token + /// Backup result Task BackupAsync(DriverInfo driverInfo, string backupPath, CancellationToken cancellationToken = default); /// - /// 异步回滚驱动 /// Rolls back driver asynchronously /// - /// 备份路径 / Backup path - /// 取消令牌 / Cancellation token - /// 回滚结果 / Rollback result + /// Backup path + /// Cancellation token + /// Rollback result Task RollbackAsync(string backupPath, CancellationToken cancellationToken = default); + + /// + /// Reads driver information from local directory + /// + /// Directory path + /// Search pattern (optional, e.g., "*.inf", "*.ko") + /// Cancellation token + /// List of driver information + Task> GetDriversFromDirectoryAsync(string directoryPath, string? searchPattern = null, CancellationToken cancellationToken = default); } diff --git a/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs index fd2dd2df..bcdb417b 100644 --- a/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs +++ b/src/c#/GeneralUpdate.Drivelution/GeneralDrivelution.cs @@ -8,18 +8,15 @@ namespace GeneralUpdate.Drivelution; /// -/// 驱动更新器统一入口类 - 提供优雅的API，自动适配平台 /// Unified driver updater entry point - Provides elegant API with automatic platform adaptation /// /// -/// 使用示例 / Usage example: +/// Usage example: /// -/// // 简单使用 - 自动检测平台 /// // Simple usage - automatic platform detection /// var updater = GeneralDrivelution.Create(); /// var result = await updater.UpdateAsync(driverInfo, strategy); /// -/// // 带配置使用 /// // With configuration /// var options = new DrivelutionOptions { LogLevel = "Info" }; /// var updater = GeneralDrivelution.Create(options); @@ -29,12 +26,11 @@ namespace GeneralUpdate.Drivelution; public static class GeneralDrivelution { /// - /// 创建驱动更新器实例（自动检测当前平台） /// Creates a driver updater instance (automatically detects current platform) /// - /// 配置选项（可选）/ Configuration options (optional) - /// 适配当前平台的驱动更新器 / Platform-adapted driver updater - /// 当前平台不支持时抛出 / Thrown when platform is not supported + /// Configuration options (optional) + /// Platform-adapted driver updater + /// Thrown when platform is not supported public static IGeneralDrivelution Create(DrivelutionOptions? options = null) { var logger = options != null @@ -45,24 +41,22 @@ public static IGeneralDrivelution Create(DrivelutionOptions? options = null) } /// - /// 创建驱动更新器实例（使用自定义日志记录器） /// Creates a driver updater instance (with custom logger) /// - /// 自定义日志记录器 / Custom logger - /// 配置选项（可选）/ Configuration options (optional) - /// 适配当前平台的驱动更新器 / Platform-adapted driver updater + /// Custom logger + /// Configuration options (optional) + /// Platform-adapted driver updater public static IGeneralDrivelution Create(ILogger logger, DrivelutionOptions? options = null) { return Core.DrivelutionFactory.Create(logger, options); } /// - /// 快速更新驱动（使用默认配置） /// Quick driver update (with default configuration) /// - /// 驱动信息 / Driver information - /// 取消令牌 / Cancellation token - /// 更新结果 / Update result + /// Driver information + /// Cancellation token + /// Update result public static async Task QuickUpdateAsync( DriverInfo driverInfo, CancellationToken cancellationToken = default) @@ -79,13 +73,12 @@ public static async Task QuickUpdateAsync( } /// - /// 快速更新驱动（带自定义策略） /// Quick driver update (with custom strategy) /// - /// 驱动信息 / Driver information - /// 更新策略 / Update strategy - /// 取消令牌 / Cancellation token - /// 更新结果 / Update result + /// Driver information + /// Update strategy + /// Cancellation token + /// Update result public static async Task QuickUpdateAsync( DriverInfo driverInfo, UpdateStrategy strategy, @@ -96,12 +89,11 @@ public static async Task QuickUpdateAsync( } /// - /// 验证驱动文件（自动选择平台验证器） /// Validates driver file (automatically selects platform validator) /// - /// 驱动信息 / Driver information - /// 取消令牌 / Cancellation token - /// 是否验证通过 / Whether validation passed + /// Driver information + /// Cancellation token + /// Whether validation passed public static async Task ValidateAsync( DriverInfo driverInfo, CancellationToken cancellationToken = default) @@ -111,10 +103,9 @@ public static async Task ValidateAsync( } /// - /// 获取当前平台信息 /// Gets current platform information /// - /// 平台信息 / Platform information + /// Platform information public static PlatformInfo GetPlatformInfo() { return new PlatformInfo @@ -126,31 +117,45 @@ public static PlatformInfo GetPlatformInfo() SystemVersion = CompatibilityChecker.GetSystemVersion() }; } + + /// + /// Reads driver information from local directory + /// + /// Directory path + /// Search pattern (optional, e.g., "*.inf", "*.ko") + /// Cancellation token + /// List of driver information + public static async Task> GetDriversFromDirectoryAsync( + string directoryPath, + string? searchPattern = null, + CancellationToken cancellationToken = default) + { + var updater = Create(); + return await updater.GetDriversFromDirectoryAsync(directoryPath, searchPattern, cancellationToken); + } } /// -/// 平台信息 /// Platform information /// public class PlatformInfo { - /// 平台名称 / Platform name + /// Platform name public string Platform { get; set; } = string.Empty; - /// 是否支持 / Is supported + /// Is supported public bool IsSupported { get; set; } - /// 操作系统 / Operating system + /// Operating system public string OperatingSystem { get; set; } = string.Empty; - /// 系统架构 / Architecture + /// Architecture public string Architecture { get; set; } = string.Empty; - /// 系统版本 / System version + /// System version public string SystemVersion { get; set; } = string.Empty; /// - /// 返回平台信息的字符串表示 /// Returns string representation of platform information /// public override string ToString() diff --git a/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs index 710df524..fa6f5058 100644 --- a/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs +++ b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs @@ -359,4 +359,243 @@ private string GenerateBackupPath(DriverInfo driverInfo, string baseBackupPath) var fileName = Path.GetFileName(driverInfo.FilePath); return Path.Combine(baseBackupPath, fileName); } + + /// + public async Task> GetDriversFromDirectoryAsync( + string directoryPath, + string? searchPattern = null, + CancellationToken cancellationToken = default) + { + var driverInfoList = new List(); + + try + { + _logger.Information("Reading driver information from directory: {DirectoryPath}", directoryPath); + + if (!Directory.Exists(directoryPath)) + { + _logger.Warning("Directory not found: {DirectoryPath}", directoryPath); + return driverInfoList; + } + + // Default to kernel modules for Linux + var pattern = searchPattern ?? "*.ko"; + var driverFiles = Directory.GetFiles(directoryPath, pattern, SearchOption.AllDirectories); + + // Also look for .deb and .rpm packages if no specific pattern was provided + if (searchPattern == null) + { + var debFiles = Directory.GetFiles(directoryPath, "*.deb", SearchOption.AllDirectories); + var rpmFiles = Directory.GetFiles(directoryPath, "*.rpm", SearchOption.AllDirectories); + driverFiles = driverFiles.Concat(debFiles).Concat(rpmFiles).ToArray(); + } + + _logger.Information("Found {Count} driver files matching pattern: {Pattern}", driverFiles.Length, pattern); + + foreach (var filePath in driverFiles) + { + if (cancellationToken.IsCancellationRequested) + break; + + try + { + var driverInfo = await ParseDriverFileAsync(filePath, cancellationToken); + if (driverInfo != null) + { + driverInfoList.Add(driverInfo); + _logger.Information("Parsed driver: {DriverName} v{Version}", driverInfo.Name, driverInfo.Version); + } + } + catch (Exception ex) + { + _logger.Warning(ex, "Failed to parse driver file: {FilePath}", filePath); + } + } + + _logger.Information("Successfully loaded {Count} driver(s) from directory", driverInfoList.Count); + } + catch (Exception ex) + { + _logger.Error(ex, "Error reading drivers from directory: {DirectoryPath}", directoryPath); + } + + return driverInfoList; + } + + /// + /// Parses driver file information + /// + private async Task ParseDriverFileAsync(string filePath, CancellationToken cancellationToken) + { + try + { + var fileInfo = new FileInfo(filePath); + var fileName = Path.GetFileNameWithoutExtension(filePath); + var extension = Path.GetExtension(filePath).ToLowerInvariant(); + + var driverInfo = new DriverInfo + { + Name = fileName, + FilePath = filePath, + TargetOS = "Linux", + Architecture = Environment.Is64BitOperatingSystem ? "x64" : "x86" + }; + + // Parse based on file type + if (extension == ".ko") + { + await ParseKernelModuleAsync(filePath, driverInfo, cancellationToken); + } + else if (extension == ".deb") + { + await ParseDebPackageAsync(filePath, driverInfo, cancellationToken); + } + else if (extension == ".rpm") + { + await ParseRpmPackageAsync(filePath, driverInfo, cancellationToken); + } + + // Get file hash for integrity validation + driverInfo.Hash = await HashValidator.ComputeHashAsync(filePath, "SHA256", cancellationToken); + driverInfo.HashAlgorithm = "SHA256"; + + return driverInfo; + } + catch (Exception ex) + { + _logger.Warning(ex, "Failed to parse driver file: {FilePath}", filePath); + return null; + } + } + + /// + /// Parses kernel module + /// + private async Task ParseKernelModuleAsync(string koPath, DriverInfo driverInfo, CancellationToken cancellationToken) + { + try + { + // Try to get module info using modinfo command + var output = await ExecuteCommandAsync("modinfo", koPath, cancellationToken); + var lines = output.Split('\n'); + + foreach (var line in lines) + { + var trimmedLine = line.Trim(); + + if (trimmedLine.StartsWith("version:", StringComparison.OrdinalIgnoreCase)) + { + driverInfo.Version = trimmedLine.Substring(8).Trim(); + } + else if (trimmedLine.StartsWith("description:", StringComparison.OrdinalIgnoreCase)) + { + driverInfo.Description = trimmedLine.Substring(12).Trim(); + } + else if (trimmedLine.StartsWith("alias:", StringComparison.OrdinalIgnoreCase)) + { + var alias = trimmedLine.Substring(6).Trim(); + if (string.IsNullOrEmpty(driverInfo.HardwareId)) + { + driverInfo.HardwareId = alias; + } + } + } + + if (string.IsNullOrEmpty(driverInfo.Version)) + { + driverInfo.Version = "1.0.0"; + } + } + catch (Exception ex) + { + _logger.Debug(ex, "Could not get module info for: {KoPath}", koPath); + driverInfo.Version = "1.0.0"; + } + } + + /// + /// Parses Debian package + /// + private async Task ParseDebPackageAsync(string debPath, DriverInfo driverInfo, CancellationToken cancellationToken) + { + try + { + // Try to get package info using dpkg-deb command + // Use proper argument passing to avoid injection issues + var escapedPath = debPath.Replace("'", "'\\''"); + var output = await ExecuteCommandAsync("dpkg-deb", $"-I '{escapedPath}'", cancellationToken); + var lines = output.Split('\n'); + + foreach (var line in lines) + { + var trimmedLine = line.Trim(); + + if (trimmedLine.StartsWith("Version:", StringComparison.OrdinalIgnoreCase)) + { + driverInfo.Version = trimmedLine.Substring(8).Trim(); + } + else if (trimmedLine.StartsWith("Description:", StringComparison.OrdinalIgnoreCase)) + { + driverInfo.Description = trimmedLine.Substring(12).Trim(); + } + } + + if (string.IsNullOrEmpty(driverInfo.Version)) + { + driverInfo.Version = "1.0.0"; + } + } + catch (Exception ex) + { + _logger.Debug(ex, "Could not get package info for: {DebPath}", debPath); + driverInfo.Version = "1.0.0"; + } + } + + /// + /// Parses RPM package + /// + private async Task ParseRpmPackageAsync(string rpmPath, DriverInfo driverInfo, CancellationToken cancellationToken) + { + try + { + // Try to get package info using rpm command + // Use proper argument passing to avoid injection issues + var escapedPath = rpmPath.Replace("'", "'\\''"); + var output = await ExecuteCommandAsync("rpm", $"-qip '{escapedPath}'", cancellationToken); + var lines = output.Split('\n'); + + foreach (var line in lines) + { + var trimmedLine = line.Trim(); + + if (trimmedLine.StartsWith("Version", StringComparison.OrdinalIgnoreCase)) + { + var parts = trimmedLine.Split(':'); + if (parts.Length > 1) + { + driverInfo.Version = parts[1].Trim(); + } + } + else if (trimmedLine.StartsWith("Summary", StringComparison.OrdinalIgnoreCase)) + { + var parts = trimmedLine.Split(':'); + if (parts.Length > 1) + { + driverInfo.Description = parts[1].Trim(); + } + } + } + + if (string.IsNullOrEmpty(driverInfo.Version)) + { + driverInfo.Version = "1.0.0"; + } + } + catch (Exception ex) + { + _logger.Debug(ex, "Could not get package info for: {RpmPath}", rpmPath); + driverInfo.Version = "1.0.0"; + } + } } diff --git a/src/c#/GeneralUpdate.Drivelution/MacOS/Implementation/MacOsGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/MacOS/Implementation/MacOsGeneralDrivelution.cs index bf581403..2cfd84a6 100644 --- a/src/c#/GeneralUpdate.Drivelution/MacOS/Implementation/MacOsGeneralDrivelution.cs +++ b/src/c#/GeneralUpdate.Drivelution/MacOS/Implementation/MacOsGeneralDrivelution.cs @@ -65,6 +65,16 @@ public Task RollbackAsync( throw new PlatformNotSupportedException( "MacOS driver rollback is not yet implemented."); } + + /// + public Task> GetDriversFromDirectoryAsync( + string directoryPath, + string? searchPattern = null, + CancellationToken cancellationToken = default) + { + throw new PlatformNotSupportedException( + "MacOS driver directory reading is not yet implemented."); + } } /// diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs index 0e8ff2be..df7ba8fe 100644 --- a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs +++ b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs @@ -457,4 +457,198 @@ private string GetSuggestedResolution(ErrorType type) _ => "Contact support for assistance" }; } + + /// + public async Task> GetDriversFromDirectoryAsync( + string directoryPath, + string? searchPattern = null, + CancellationToken cancellationToken = default) + { + var driverInfoList = new List(); + + try + { + _logger.Information("Reading driver information from directory: {DirectoryPath}", directoryPath); + + if (!Directory.Exists(directoryPath)) + { + _logger.Warning("Directory not found: {DirectoryPath}", directoryPath); + return driverInfoList; + } + + // Default to .inf files for Windows + var pattern = searchPattern ?? "*.inf"; + var driverFiles = Directory.GetFiles(directoryPath, pattern, SearchOption.AllDirectories); + + _logger.Information("Found {Count} driver files matching pattern: {Pattern}", driverFiles.Length, pattern); + + foreach (var filePath in driverFiles) + { + if (cancellationToken.IsCancellationRequested) + break; + + try + { + var driverInfo = await ParseDriverFileAsync(filePath, cancellationToken); + if (driverInfo != null) + { + driverInfoList.Add(driverInfo); + _logger.Information("Parsed driver: {DriverName} v{Version}", driverInfo.Name, driverInfo.Version); + } + } + catch (Exception ex) + { + _logger.Warning(ex, "Failed to parse driver file: {FilePath}", filePath); + } + } + + _logger.Information("Successfully loaded {Count} driver(s) from directory", driverInfoList.Count); + } + catch (Exception ex) + { + _logger.Error(ex, "Error reading drivers from directory: {DirectoryPath}", directoryPath); + } + + return driverInfoList; + } + + /// + /// Parses driver file information + /// + private async Task ParseDriverFileAsync(string filePath, CancellationToken cancellationToken) + { + try + { + var fileInfo = new FileInfo(filePath); + var fileName = Path.GetFileNameWithoutExtension(filePath); + + var driverInfo = new DriverInfo + { + Name = fileName, + FilePath = filePath, + TargetOS = "Windows", + Architecture = Environment.Is64BitOperatingSystem ? "x64" : "x86" + }; + + // For .inf files, try to parse version and other metadata + if (filePath.EndsWith(".inf", StringComparison.OrdinalIgnoreCase)) + { + await ParseInfFileAsync(filePath, driverInfo, cancellationToken); + } + + // Get file hash for integrity validation + driverInfo.Hash = await HashValidator.ComputeHashAsync(filePath, "SHA256", cancellationToken); + driverInfo.HashAlgorithm = "SHA256"; + + // Get signature information if available + try + { + if (WindowsSignatureHelper.IsFileSigned(filePath)) + { + // Try to extract publisher from certificate + using var cert2 = new System.Security.Cryptography.X509Certificates.X509Certificate2(filePath); + var subject = cert2.Subject; + + // Extract CN (Common Name) from subject + var cnIndex = subject.IndexOf("CN="); + if (cnIndex >= 0) + { + var cnStart = cnIndex + 3; + var cnEnd = subject.IndexOf(',', cnStart); + + string publisher; + if (cnEnd > cnStart) + { + publisher = subject.Substring(cnStart, cnEnd - cnStart); + } + else + { + // No comma after CN, take the rest of the string + publisher = subject.Substring(cnStart); + } + + if (!string.IsNullOrEmpty(publisher)) + { + driverInfo.TrustedPublishers.Add(publisher); + } + } + } + } + catch (Exception ex) + { + _logger.Debug(ex, "Could not get signature for file: {FilePath}", filePath); + } + + return driverInfo; + } + catch (Exception ex) + { + _logger.Warning(ex, "Failed to parse driver file: {FilePath}", filePath); + return null; + } + } + + /// + /// Parses INF file + /// + private async Task ParseInfFileAsync(string infPath, DriverInfo driverInfo, CancellationToken cancellationToken) + { + try + { + var content = await File.ReadAllTextAsync(infPath, cancellationToken); + var lines = content.Split('\n'); + + foreach (var line in lines) + { + var trimmedLine = line.Trim(); + + // Parse version + if (trimmedLine.StartsWith("DriverVer", StringComparison.OrdinalIgnoreCase)) + { + var parts = trimmedLine.Split('='); + if (parts.Length > 1) + { + var verParts = parts[1].Split(','); + if (verParts.Length > 1) + { + driverInfo.Version = verParts[1].Trim(); + } + if (verParts.Length > 0 && DateTime.TryParse(verParts[0].Trim(), out var releaseDate)) + { + driverInfo.ReleaseDate = releaseDate; + } + } + } + // Parse description + else if (trimmedLine.StartsWith("DriverDesc", StringComparison.OrdinalIgnoreCase)) + { + var parts = trimmedLine.Split('='); + if (parts.Length > 1) + { + driverInfo.Description = parts[1].Trim().Trim('"', '%'); + } + } + // Parse hardware ID + else if (trimmedLine.StartsWith("HardwareId", StringComparison.OrdinalIgnoreCase) || + trimmedLine.Contains("HW_ID", StringComparison.OrdinalIgnoreCase)) + { + var parts = trimmedLine.Split('='); + if (parts.Length > 1) + { + driverInfo.HardwareId = parts[1].Trim().Trim('"'); + } + } + } + + // If version is still empty, try to infer from filename or use default + if (string.IsNullOrEmpty(driverInfo.Version)) + { + driverInfo.Version = "1.0.0"; + } + } + catch (Exception ex) + { + _logger.Debug(ex, "Could not parse INF file: {InfPath}", infPath); + } + } }