Protoype of refactoring work with Test code too. Pushing these commit…

.github/actions/spelling/expect.txt

@@ -210,6 +210,7 @@ SRL
 srs
 Standalone
 startswith
+streambuf
 strtoull
 subdir
 subkey

src/AppInstallerCLICore/AppInstallerCLICore.vcxproj

@@ -177,6 +177,7 @@
   <ItemGroup>
     <ClInclude Include="Argument.h" />
     <ClInclude Include="ChannelStreams.h" />
+    <ClInclude Include="COMContext.h" />
     <ClInclude Include="Command.h" />
     <ClInclude Include="Commands\CompleteCommand.h" />
     <ClInclude Include="Commands\ExperimentalCommand.h" />
@@ -221,6 +222,7 @@
     <ClInclude Include="Workflows\WorkflowBase.h" />
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="COMContext.cpp" />
     <ClCompile Include="Commands\ImportCommand.cpp" />
     <ClCompile Include="PackageCollection.cpp" />
     <ClCompile Include="Argument.cpp" />

src/AppInstallerCLICore/AppInstallerCLICore.vcxproj.filters

@@ -152,6 +152,9 @@
     <ClInclude Include="ExecutionContext.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="COMContext.h">
+      <Filter>Public</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="pch.cpp">
@@ -271,6 +274,9 @@
     <ClCompile Include="Commands\ImportCommand.cpp">
       <Filter>Commands</Filter>
     </ClCompile>
+    <ClCompile Include="COMContext.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="PropertySheet.props" />

src/AppInstallerCLICore/COMContext.cpp

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "pch.h"
+#include "COMContext.h"
+
+namespace AppInstaller
+{
+
+    NullStream::NullStream()
+    {
+        m_nullOut.reset(new std::ostream(&m_nullStreamBuf));
+        m_nullIn.reset(new std::istream(&m_nullStreamBuf));
+    }
+
+    void COMContext::BeginProgress()
+    {
+        m_comProgressCallback(ReportType::BeginProgress, 0, 0, ProgressType::None, m_executionStage);
+    };
+
+    void COMContext::OnProgress(uint64_t current, uint64_t maximum, ProgressType progressType)
+    {
+        m_comProgressCallback(ReportType::Progressing, current, maximum, progressType, m_executionStage);
+    }
+
+    void COMContext::EndProgress(bool)
+    {
+        m_comProgressCallback(ReportType::EndProgress, 0, 0, ProgressType::None, m_executionStage);
+    };
+
+    void COMContext::SetExecutionStage(CLI::Workflow::ExecutionStage executionStage, bool)
+    {
+        m_executionStage = executionStage;
+        m_comProgressCallback(ReportType::ExecutionPhaseUpdate, 0, 0, ProgressType::None, m_executionStage);
+    }
+}

src/AppInstallerCLICore/COMContext.h

@@ -0,0 +1,69 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+#include "pch.h"
+#include "..\AppInstallerCommonCore\Public\AppInstallerProgress.h"
+#include "ExecutionContext.h"
+#include "Workflows/WorkflowBase.h"
+
+namespace AppInstaller
+{
+    enum class ReportType: uint32_t
+    {
+        ExecutionPhaseUpdate,
+        BeginProgress,
+        Progressing,
+        EndProgress,
+    };
+
+    class NullStreamBuf : public std::streambuf {};
+
+    struct NullStream
+    {
+        NullStream();
+
+        ~NullStream() = default;
+
+    protected:
+        NullStreamBuf m_nullStreamBuf;
+        std::unique_ptr<std::ostream> m_nullOut;
+        std::unique_ptr<std::istream> m_nullIn;
+    };
+
+    typedef std::function<void(ReportType reportType, uint64_t current, uint64_t maximum, ProgressType progressType, CLI::Workflow::ExecutionStage executionPhase)> ProgressCallBackFunction;
+
+    // NullStream constructs the Stream parameters for Context constructor
+    // Hence, NullStream should always precede Context in base class order of COMContext's inheritance
+    struct COMContext : IProgressSink, NullStream, CLI::Execution::Context
+    {
+        // When no Console streams need involvement, construct NullStreams instead to pass to Context
+        COMContext() : NullStream(), CLI::Execution::Context(*m_nullOut, *m_nullIn)
+        {
+            Reporter.SetProgressSink(this);
+        }
+
+        COMContext(std::ostream& out, std::istream& in) : CLI::Execution::Context(out, in) 
+        {
+            Reporter.SetProgressSink(this);
+        }
+
+        ~COMContext() = default;
+
+        // IProgressSink
+        void BeginProgress() override;
+        void OnProgress(uint64_t current, uint64_t maximum, ProgressType type) override;
+        void EndProgress(bool) override;
+
+        //Execution::Context
+        void SetExecutionStage(CLI::Workflow::ExecutionStage executionPhase, bool);
+
+        void SetProgressCallbackFunction(ProgressCallBackFunction&& f)
+        {
+            m_comProgressCallback = std::move(f);
+        }
+
+    private:
+        CLI::Workflow::ExecutionStage m_executionStage = CLI::Workflow::ExecutionStage::Initial;
+        ProgressCallBackFunction m_comProgressCallback;
+    };
+}

src/AppInstallerCLICore/Command.cpp

@@ -770,4 +770,59 @@ namespace AppInstaller::CLI
 
         return arguments;
     }
+
+    int Execute(Execution::Context& context, std::unique_ptr<Command>& command)
+    {
+        try
+        {
+            if (!Settings::User().GetWarnings().empty())
+            {
+                context.Reporter.Warn() << Resource::String::SettingsWarnings << std::endl;
+            }
+
+            command->Execute(context);
+        }
+        // Exceptions that may occur in the process of executing an arbitrary command
+        catch (const wil::ResultException& re)
+        {
+            // Even though they are logged at their source, log again here for completeness.
+            Logging::Telemetry().LogException(command->FullName(), "wil::ResultException", re.what());
+            context.Reporter.Error() <<
+                Resource::String::UnexpectedErrorExecutingCommand << ' ' << std::endl <<
+                GetUserPresentableMessage(re) << std::endl;
+            return re.GetErrorCode();
+        }
+        catch (const winrt::hresult_error& hre)
+        {
+            std::string message = GetUserPresentableMessage(hre);
+            Logging::Telemetry().LogException(command->FullName(), "winrt::hresult_error", message);
+            context.Reporter.Error() <<
+                Resource::String::UnexpectedErrorExecutingCommand << ' ' << std::endl <<
+                message << std::endl;
+            return hre.code();
+        }
+        catch (const std::exception& e)
+        {
+            Logging::Telemetry().LogException(command->FullName(), "std::exception", e.what());
+            context.Reporter.Error() <<
+                Resource::String::UnexpectedErrorExecutingCommand << ' ' << std::endl <<
+                GetUserPresentableMessage(e) << std::endl;
+            return APPINSTALLER_CLI_ERROR_COMMAND_FAILED;
+        }
+        catch (...)
+        {
+            LOG_CAUGHT_EXCEPTION();
+            Logging::Telemetry().LogException(command->FullName(), "unknown", {});
+            context.Reporter.Error() <<
+                Resource::String::UnexpectedErrorExecutingCommand << " ???"_liv << std::endl;
+            return APPINSTALLER_CLI_ERROR_COMMAND_FAILED;
+        }
+
+        if (SUCCEEDED(context.GetTerminationHR()))
+        {
+            Logging::Telemetry().LogCommandSuccess(command->FullName());
+        }
+
+        return context.GetTerminationHR();
+    }
 }

src/AppInstallerCLICore/Command.h

@@ -112,4 +112,6 @@ namespace AppInstaller::CLI
 
         return result;
     }
+
+    int Execute(Execution::Context& context, std::unique_ptr<Command>& command);
 }

src/AppInstallerCLICore/Core.cpp

@@ -6,6 +6,7 @@
 #include "ExecutionContext.h"
 #include "Workflows/WorkflowBase.h"
 #include <winget/UserSettings.h>
+#include "Commands/InstallCommand.h"
 
 using namespace winrt;
 using namespace winrt::Windows::Foundation;
@@ -115,63 +116,12 @@ namespace AppInstaller::CLI
             return APPINSTALLER_CLI_ERROR_INVALID_CL_ARGUMENTS;
         }
 
-        try
-        {
-            if (!Settings::User().GetWarnings().empty())
-            {
-                context.Reporter.Warn() << Resource::String::SettingsWarnings << std::endl;
-            }
-
-            command->Execute(context);
-        }
-        // Exceptions that may occur in the process of executing an arbitrary command
-        catch (const wil::ResultException& re)
-        {
-            // Even though they are logged at their source, log again here for completeness.
-            Logging::Telemetry().LogException(command->FullName(), "wil::ResultException", re.what());
-            context.Reporter.Error() <<
-                Resource::String::UnexpectedErrorExecutingCommand << ' ' << std::endl <<
-                GetUserPresentableMessage(re) << std::endl;
-            return re.GetErrorCode();
-        }
-        catch (const winrt::hresult_error& hre)
-        {
-            std::string message = GetUserPresentableMessage(hre);
-            Logging::Telemetry().LogException(command->FullName(), "winrt::hresult_error", message);
-            context.Reporter.Error() <<
-                Resource::String::UnexpectedErrorExecutingCommand << ' ' << std::endl <<
-                message << std::endl;
-            return hre.code();
-        }
-        catch (const std::exception& e)
-        {
-            Logging::Telemetry().LogException(command->FullName(), "std::exception", e.what());
-            context.Reporter.Error() <<
-                Resource::String::UnexpectedErrorExecutingCommand << ' ' << std::endl <<
-                GetUserPresentableMessage(e) << std::endl;
-            return APPINSTALLER_CLI_ERROR_COMMAND_FAILED;
-        }
-        catch (...)
-        {
-            LOG_CAUGHT_EXCEPTION();
-            Logging::Telemetry().LogException(command->FullName(), "unknown", {});
-            context.Reporter.Error() <<
-                Resource::String::UnexpectedErrorExecutingCommand << " ???"_liv << std::endl;
-            return APPINSTALLER_CLI_ERROR_COMMAND_FAILED;
-        }
-
-        if (SUCCEEDED(context.GetTerminationHR()))
-        {
-            Logging::Telemetry().LogCommandSuccess(command->FullName());
-        }
-
-        return context.GetTerminationHR();
+        return Execute(context, command);
     }
     // End of the line exceptions that are not ever expected.
     // Telemetry cannot be reliable beyond this point, so don't let these happen.
     catch (...)
     {
         return APPINSTALLER_CLI_ERROR_INTERNAL_ERROR;
     }
-
 }

src/AppInstallerCLICore/ExecutionContext.cpp

@@ -126,4 +126,18 @@ namespace AppInstaller::CLI::Execution
         m_isTerminated = true;
         m_terminationHR = hr;
     }
+
+    void Context::SetExecutionStage(Workflow::ExecutionStage stage, bool allowBackward)
+    {     
+        if (m_executionStage == stage)
+        {
+            return;
+        }
+        else if (m_executionStage > stage && !allowBackward)
+        {
+            THROW_HR_MSG(HRESULT_FROM_WIN32(ERROR_INVALID_STATE), "Reporting ExecutionStage to an earlier Stage without allowBackward as true");
+        }
+
+        m_executionStage = stage;
+    }
 }

src/AppInstallerCLICore/ExecutionContext.h

@@ -101,6 +101,8 @@ namespace AppInstaller::CLI::Execution
             WI_ClearAllFlags(m_flags, flags);
         }
 
+        virtual void SetExecutionStage(Workflow::ExecutionStage stage, bool);
+
 #ifndef AICLI_DISABLE_TEST_HOOKS
         // Enable tests to override behavior
         virtual bool ShouldExecuteWorkflowTask(const Workflow::WorkflowTask&) { return true; }
@@ -112,5 +114,6 @@ namespace AppInstaller::CLI::Execution
         HRESULT m_terminationHR = S_OK;
         size_t m_CtrlSignalCount = 0;
         ContextFlag m_flags = ContextFlag::None;
+        Workflow::ExecutionStage m_executionStage = Workflow::ExecutionStage::Initial;
     };
 }

src/AppInstallerCLICore/ExecutionContextData.h

@@ -36,7 +36,6 @@ namespace AppInstaller::CLI::Execution
         InstallerArgs,
         CompletionData,
         InstalledPackageVersion,
-        ExecutionStage,
         UninstallString,
         PackageFamilyNames,
         ProductCodes,
@@ -137,12 +136,6 @@ namespace AppInstaller::CLI::Execution
             using value_t = std::shared_ptr<Repository::IPackageVersion>;
         };
 
-        template <>
-        struct DataMapping<Data::ExecutionStage>
-        {
-            using value_t = Workflow::ExecutionStage;
-        };
-
         template <>
         struct DataMapping<Data::UninstallString>
         {

src/AppInstallerCLICore/ExecutionReporter.cpp

@@ -20,7 +20,9 @@ namespace AppInstaller::CLI::Execution
         m_in(inStream),
         m_progressBar(std::in_place, outStream, IsVTEnabled()),
         m_spinner(std::in_place, outStream, IsVTEnabled())
-    {}
+    {
+        SetProgressSink(this);
+    }
 
     Reporter::~Reporter()
     {
@@ -120,6 +122,22 @@ namespace AppInstaller::CLI::Execution
             m_progressBar->ShowProgress(current, maximum, type);
         }
     }
+
+    void Reporter::BeginProgress()
+    {
+        GetBasicOutputStream() << VirtualTerminal::Cursor::Visibility::DisableShow;
+        ShowIndefiniteProgress(true);
+    };
+
+    void Reporter::EndProgress(bool hideProgressWhenDone)
+    {
+        ShowIndefiniteProgress(false);
+        if (m_progressBar)
+        {
+            m_progressBar->EndProgress(hideProgressWhenDone);
+        }
+        GetBasicOutputStream() << VirtualTerminal::Cursor::Visibility::EnableShow;
+    };
 
     void Reporter::SetProgressCallback(ProgressCallback* callback)
     {