Add upgrade functionality in Com api

src/AppInstallerCLICore/Commands/COMInstallCommand.cpp

@@ -27,8 +27,7 @@ namespace AppInstaller::CLI
     void COMInstallCommand::ExecuteInternal(Context& context) const
     {
         context <<
-            Workflow::GetInstallerHash <<
-            Workflow::VerifyInstallerHash <<
+            Workflow::ReverifyInstallerHash <<
             Workflow::InstallPackageInstaller;
     }
 }

src/AppInstallerCLICore/Workflows/DownloadFlow.cpp

@@ -462,7 +462,7 @@ namespace AppInstaller::CLI::Workflow
         }
     }
 
-    void GetInstallerHash(Execution::Context& context)
+    void ReverifyInstallerHash(Execution::Context& context)
     {
         const auto& installer = context.Get<Execution::Data::Installer>().value();
 
@@ -490,6 +490,8 @@ namespace AppInstaller::CLI::Workflow
             AICLI_LOG(CLI, Error, << "Installer file not found.");
             AICLI_TERMINATE_CONTEXT(HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND));
         }
+
+        context << VerifyInstallerHash;
     }
 
     void RenameDownloadedInstaller(Execution::Context& context)

src/AppInstallerCLICore/Workflows/DownloadFlow.h

@@ -35,12 +35,11 @@ namespace AppInstaller::CLI::Workflow
     // Outputs: HashPair
     void GetMsixSignatureHash(Execution::Context& context);
 
-    // Gets the hash of the downloaded installer.
-    // Downloading already computes the hash, so this is only needed to re-verify the installer hash.
+    // Re-verify the installer hash. This is used in Com install commands where download and install are in separate phases.
     // Required Args: None
     // Inputs: InstallerPath, Installer
     // Outputs: HashPair
-    void GetInstallerHash(Execution::Context& context);
+    void ReverifyInstallerHash(Execution::Context& context);
 
     // Verifies that the downloaded installer hash matches the hash in the manifest.
     // Required Args: None

src/Microsoft.Management.Deployment.Client/InstallOptions.cpp

@@ -90,4 +90,12 @@ namespace winrt::Microsoft::Management::Deployment::implementation
     {
         throw hresult_not_implemented();
     }
+    bool InstallOptions::AllowUpgradeToUnknownVersion()
+    {
+        throw hresult_not_implemented();
+    }
+    void InstallOptions::AllowUpgradeToUnknownVersion(bool)
+    {
+        throw hresult_not_implemented();
+    }
 }

src/Microsoft.Management.Deployment.Client/PackageManager.cpp

@@ -38,5 +38,8 @@ namespace winrt::Microsoft::Management::Deployment::implementation
     {
         throw hresult_not_implemented();
     }
-
+    winrt::Windows::Foundation::IAsyncOperationWithProgress<winrt::Microsoft::Management::Deployment::InstallResult, winrt::Microsoft::Management::Deployment::InstallProgress> PackageManager::UpgradePackageAsync(winrt::Microsoft::Management::Deployment::CatalogPackage package, winrt::Microsoft::Management::Deployment::InstallOptions)
+    {
+        throw hresult_not_implemented();
+    }
 }

src/Microsoft.Management.Deployment/CatalogPackage.h

@@ -22,7 +22,7 @@ namespace winrt::Microsoft::Management::Deployment::implementation
         winrt::Microsoft::Management::Deployment::PackageVersionInfo DefaultInstallVersion();
         winrt::Microsoft::Management::Deployment::PackageVersionInfo GetPackageVersionInfo(winrt::Microsoft::Management::Deployment::PackageVersionId const& versionKey);
         bool IsUpdateAvailable();
-        
+
 #if !defined(INCLUDE_ONLY_INTERFACE_METHODS)
     private:
         ::AppInstaller::Repository::Source m_source;

src/Microsoft.Management.Deployment/Converters.cpp

@@ -198,6 +198,9 @@ namespace winrt::Microsoft::Management::Deployment::implementation
         case APPINSTALLER_CLI_ERROR_NO_APPLICABLE_INSTALLER:
             resultStatus = winrt::Microsoft::Management::Deployment::InstallResultStatus::NoApplicableInstallers;
             break;
+        case APPINSTALLER_CLI_ERROR_UPDATE_NOT_APPLICABLE:
+            resultStatus = winrt::Microsoft::Management::Deployment::InstallResultStatus::NoApplicableUpgrade;
+            break;
         case APPINSTALLER_CLI_ERROR_CANNOT_WRITE_TO_UPLEVEL_INDEX:
         case APPINSTALLER_CLI_ERROR_INDEX_INTEGRITY_COMPROMISED:
         case APPINSTALLER_CLI_ERROR_YAML_INIT_FAILED:

src/Microsoft.Management.Deployment/InstallOptions.cpp

@@ -104,6 +104,14 @@ namespace winrt::Microsoft::Management::Deployment::implementation
     {
         return m_allowedArchitectures;
     }
+    bool InstallOptions::AllowUpgradeToUnknownVersion()
+    {
+        return m_allowUpgradeToUnknownVersion;
+    }
+    void InstallOptions::AllowUpgradeToUnknownVersion(bool value)
+    {
+        m_allowUpgradeToUnknownVersion = value;
+    }
 
     CoCreatableMicrosoftManagementDeploymentClass(InstallOptions);
 }

src/Microsoft.Management.Deployment/InstallOptions.h

@@ -33,6 +33,8 @@ namespace winrt::Microsoft::Management::Deployment::implementation
         hstring AdditionalPackageCatalogArguments();
         void AdditionalPackageCatalogArguments(hstring const& value);
         winrt::Windows::Foundation::Collections::IVector<winrt::Windows::System::ProcessorArchitecture> AllowedArchitectures();
+        bool AllowUpgradeToUnknownVersion();
+        void AllowUpgradeToUnknownVersion(bool value);
 
 #if !defined(INCLUDE_ONLY_INTERFACE_METHODS)
     private:
@@ -47,6 +49,7 @@ namespace winrt::Microsoft::Management::Deployment::implementation
         std::wstring m_additionalPackageCatalogArguments = L"";
         Windows::Foundation::Collections::IVector<Windows::System::ProcessorArchitecture> m_allowedArchitectures{
             winrt::single_threaded_vector<winrt::Windows::System::ProcessorArchitecture>() };
+        bool m_allowUpgradeToUnknownVersion = false;
 #endif
     };
 }

src/Microsoft.Management.Deployment/PackageManager.cpp

@@ -341,6 +341,9 @@ namespace winrt::Microsoft::Management::Deployment::implementation
         Microsoft::Management::Deployment::PackageVersionInfo packageVersionInfo = GetPackageVersionInfo(package, options);
         AddPackageManifestToContext(packageVersionInfo, context.get());
 
+        // If the installer has dependencies, DependencySource needs to be set.
+        context->Args.AddArg(Execution::Args::Type::DependencySource, ::AppInstaller::Utility::ConvertToUTF8(packageVersionInfo.PackageCatalog().Info().Name()));
+
         // Note: AdditionalPackageCatalogArguments is not needed during install since the manifest is already known so no additional calls to the source are needed. The property is deprecated.
         return context;
     }
@@ -402,7 +405,8 @@ namespace winrt::Microsoft::Management::Deployment::implementation
         std::shared_ptr<Execution::OrchestratorQueueItem> queueItemParam,
         winrt::Microsoft::Management::Deployment::CatalogPackage package = nullptr,
         winrt::Microsoft::Management::Deployment::InstallOptions options = nullptr,
-        std::wstring callerProcessInfoString = {})
+        std::wstring callerProcessInfoString = {},
+        bool isUpgrade = false)
     {
         winrt::hresult terminationHR = S_OK;
         hstring correlationData = (options) ? options.CorrelationData() : L"";
@@ -422,6 +426,30 @@ namespace winrt::Microsoft::Management::Deployment::implementation
             {
                 Microsoft::Management::Deployment::PackageVersionInfo packageVersionInfo = GetPackageVersionInfo(package, options);
                 std::unique_ptr<COMContext> comContext = CreateContextFromInstallOptions(package, options, callerProcessInfoString);
+
+                if (isUpgrade)
+                {
+                    AppInstaller::Utility::VersionAndChannel installedVersion{ winrt::to_string(package.InstalledVersion().Version()), winrt::to_string(package.InstalledVersion().Channel()) };
+                    AppInstaller::Utility::VersionAndChannel upgradeVersion{ winrt::to_string(packageVersionInfo.Version()), winrt::to_string(packageVersionInfo.Channel()) };
+
+                    if (installedVersion.IsUpdatedBy(upgradeVersion) ||
+                        (options.AllowUpgradeToUnknownVersion() &&
+                         AppInstaller::Utility::ICUCaseInsensitiveEquals(installedVersion.GetChannel().ToString(), upgradeVersion.GetChannel().ToString()) &&
+                         upgradeVersion.GetVersion().IsUnknown()))
+                    {
+                        // Set upgrade flag
+                        comContext->SetFlags(AppInstaller::CLI::Execution::ContextFlag::InstallerExecutionUseUpdate);
+                        // Add installed version
+                        winrt::Microsoft::Management::Deployment::implementation::PackageVersionInfo* installedVersionInfoImpl = get_self<winrt::Microsoft::Management::Deployment::implementation::PackageVersionInfo>(package.InstalledVersion());
+                        std::shared_ptr<::AppInstaller::Repository::IPackageVersion> internalInstalledVersion = installedVersionInfoImpl->GetRepositoryPackageVersion();
+                        comContext->Add<AppInstaller::CLI::Execution::Data::InstalledPackageVersion>(internalInstalledVersion);
+                    }
+                    else
+                    {
+                        co_return GetInstallResult(executionStage, APPINSTALLER_CLI_ERROR_UPDATE_NOT_APPLICABLE, correlationData, false);
+                    }
+                }
+
                 queueItem = Execution::OrchestratorQueueItemFactory::CreateItemForInstall(std::wstring{ package.Id() }, std::wstring{ packageVersionInfo.PackageCatalog().Info().Id() }, std::move(comContext));
                 Execution::ContextOrchestrator::Instance().EnqueueAndRunItem(queueItem);
 
@@ -552,6 +580,32 @@ namespace winrt::Microsoft::Management::Deployment::implementation
         return GetInstallOperation(true /*canCancelQueueItem*/, nullptr /*queueItem*/, package, options, std::move(callerProcessInfoString));
     }
 
+    winrt::Windows::Foundation::IAsyncOperationWithProgress<winrt::Microsoft::Management::Deployment::InstallResult, winrt::Microsoft::Management::Deployment::InstallProgress> PackageManager::UpgradePackageAsync(winrt::Microsoft::Management::Deployment::CatalogPackage package, winrt::Microsoft::Management::Deployment::InstallOptions options)
+    {
+        hstring correlationData = (options) ? options.CorrelationData() : L"";
+
+        // options and catalog can both be null, package must be set.
+        WINGET_RETURN_INSTALL_RESULT_HR_IF(APPINSTALLER_CLI_ERROR_INVALID_CL_ARGUMENTS, !package);
+        // the package should have an installed version to be upgraded.
+        WINGET_RETURN_INSTALL_RESULT_HR_IF(APPINSTALLER_CLI_ERROR_INVALID_CL_ARGUMENTS, !package.InstalledVersion());
+
+        HRESULT hr = S_OK;
+        std::wstring callerProcessInfoString;
+        try
+        {
+            // Check for permissions and get caller info for telemetry.
+            // This must be done before any co_awaits since it requires info from the rpc caller thread.
+            auto [hrGetCallerId, callerProcessId] = GetCallerProcessId();
+            WINGET_RETURN_INSTALL_RESULT_HR_IF_FAILED(hrGetCallerId);
+            WINGET_RETURN_INSTALL_RESULT_HR_IF_FAILED(EnsureProcessHasCapability(Capability::PackageManagement, callerProcessId));
+            callerProcessInfoString = TryGetCallerProcessInfo(callerProcessId);
+        }
+        WINGET_CATCH_STORE(hr, APPINSTALLER_CLI_ERROR_COMMAND_FAILED);
+        WINGET_RETURN_INSTALL_RESULT_HR_IF_FAILED(hr);
+
+        return GetInstallOperation(true /*canCancelQueueItem*/, nullptr /*queueItem*/, package, options, std::move(callerProcessInfoString), true /* isUpgrade */);
+    }
+
     winrt::Windows::Foundation::IAsyncOperationWithProgress<winrt::Microsoft::Management::Deployment::InstallResult, winrt::Microsoft::Management::Deployment::InstallProgress> PackageManager::GetInstallProgress(winrt::Microsoft::Management::Deployment::CatalogPackage package, winrt::Microsoft::Management::Deployment::PackageCatalogInfo catalogInfo)
     {
         hstring correlationData;

src/Microsoft.Management.Deployment/PackageManager.h

@@ -21,9 +21,12 @@ namespace winrt::Microsoft::Management::Deployment::implementation
         winrt::Microsoft::Management::Deployment::PackageCatalogReference CreateCompositePackageCatalog(winrt::Microsoft::Management::Deployment::CreateCompositePackageCatalogOptions const& options);
         winrt::Windows::Foundation::IAsyncOperationWithProgress<winrt::Microsoft::Management::Deployment::InstallResult, winrt::Microsoft::Management::Deployment::InstallProgress> 
             InstallPackageAsync(winrt::Microsoft::Management::Deployment::CatalogPackage package, winrt::Microsoft::Management::Deployment::InstallOptions options);
-        //Contract 2.0
+        // Contract 2.0
         winrt::Windows::Foundation::IAsyncOperationWithProgress<winrt::Microsoft::Management::Deployment::InstallResult, winrt::Microsoft::Management::Deployment::InstallProgress> 
             GetInstallProgress(winrt::Microsoft::Management::Deployment::CatalogPackage package, winrt::Microsoft::Management::Deployment::PackageCatalogInfo catalogInfo);
+        // Contract 4.0
+        winrt::Windows::Foundation::IAsyncOperationWithProgress<winrt::Microsoft::Management::Deployment::InstallResult, winrt::Microsoft::Management::Deployment::InstallProgress>
+            UpgradePackageAsync(winrt::Microsoft::Management::Deployment::CatalogPackage package, winrt::Microsoft::Management::Deployment::InstallOptions options);
     };
 }
 

src/Microsoft.Management.Deployment/PackageManager.idl

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 namespace Microsoft.Management.Deployment
 {
-    [contractversion(3)]
+    [contractversion(4)]
     apicontract WindowsPackageManagerContract{};
 
     /// State of the install.
@@ -59,6 +59,7 @@ namespace Microsoft.Management.Deployment
         InstallError,
         ManifestError,
         NoApplicableInstallers,
+        NoApplicableUpgrade,
     };
 
     /// Result of the install
@@ -525,6 +526,12 @@ namespace Microsoft.Management.Deployment
             // architecture after the first will simply be ignored.
             Windows.Foundation.Collections.IVector<Windows.System.ProcessorArchitecture> AllowedArchitectures { get; };
         }
+
+        [contract(Microsoft.Management.Deployment.WindowsPackageManagerContract, 4)]
+        {
+            /// Allow the upgrade to continue for upgrade packages with manifest versions Unknown.
+            Boolean AllowUpgradeToUnknownVersion;
+        }
     }
 
     [contract(Microsoft.Management.Deployment.WindowsPackageManagerContract, 1)]
@@ -554,6 +561,12 @@ namespace Microsoft.Management.Deployment
             /// Get install progress
             Windows.Foundation.IAsyncOperationWithProgress<InstallResult, InstallProgress> GetInstallProgress(CatalogPackage package, PackageCatalogInfo catalogInfo);
         }
+
+        [contract(Microsoft.Management.Deployment.WindowsPackageManagerContract, 4)]
+        {
+            /// Upgrade the specified package
+            Windows.Foundation.IAsyncOperationWithProgress<InstallResult, InstallProgress> UpgradePackageAsync(CatalogPackage package, InstallOptions options);
+        }
     }
 
     /// Force midl3 to generate vector marshalling info.