code review changes

WillButAgain · WillButAgain · commit 855a0e7631aa · 2026-03-13T08:07:22.000-04:00
diff --git a/src/TaskManager/Plug-ins/Podman/ContainerStatusMonitor.cs b/src/TaskManager/Plug-ins/Podman/ContainerStatusMonitor.cs
@@ -84,6 +84,7 @@ public async Task Start(
             var pollingPeriod = TimeSpan.FromSeconds(1);
 
             var timeToRetry = (int)containerTimeout.TotalSeconds;
+            var completed = false;
             while (timeToRetry-- > 0)
             {
                 try
@@ -92,22 +93,43 @@ public async Task Start(
 
                     if (IsContainerCompleted(response.State))
                     {
-                        await UploadOutputArtifacts(intermediateVolumeMount, outputVolumeMounts, cancellationToken).ConfigureAwait(false);
-                        await SendCallbackMessage(taskDispatchEvent, containerId).ConfigureAwait(false);
-                        return;
+                        completed = true;
+                        break;
                     }
                 }
                 catch (Exception ex)
                 {
                     _logger.ErrorMonitoringContainerStatus(containerId, ex);
                 }
-                finally
+
+                await Task.Delay(pollingPeriod, cancellationToken).ConfigureAwait(false);
+            }
+
+            if (completed)
+            {
+                try
                 {
-                    await Task.Delay(pollingPeriod, cancellationToken).ConfigureAwait(false);
+                    await UploadOutputArtifacts(intermediateVolumeMount, outputVolumeMounts, cancellationToken).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorMonitoringContainerStatus(containerId, ex);
+                    throw;
                 }
-            }
 
-            _logger.TimedOutMonitoringContainerStatus(containerId);
+                try
+                {
+                    await SendCallbackMessage(taskDispatchEvent, containerId).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorMonitoringContainerStatus(containerId, ex);
+                }
+            }
+            else
+            {
+                _logger.TimedOutMonitoringContainerStatus(containerId);
+            }
         }
 
         internal static bool IsContainerCompleted(ContainerState state)
@@ -161,8 +183,13 @@ private async Task UploadOutputArtifacts(IStorageService storageService, IConten
             {
                 try
                 {
-                    var objectName = file.Replace(artifactsPath, string.Empty).TrimStart('/');
-                    objectName = _fileSystem.Path.Combine(destination.RelativeRootPath, objectName);
+                    var relativePart = file.StartsWith(artifactsPath, StringComparison.Ordinal)
+                        ? file.Substring(artifactsPath.Length)
+                        : file;
+                    relativePart = relativePart.TrimStart('/');
+                    var objectName = string.IsNullOrEmpty(destination.RelativeRootPath)
+                        ? relativePart
+                        : destination.RelativeRootPath.TrimEnd('/') + "/" + relativePart;
                     _logger.UploadingFile(file, destination.Bucket, objectName);
                     if (!contentTypeProvider.TryGetContentType(file, out var contentType))
                     {
@@ -175,6 +202,7 @@ private async Task UploadOutputArtifacts(IStorageService storageService, IConten
                 catch (Exception ex)
                 {
                     _logger.ErrorUploadingFile(file, ex);
+                    throw;
                 }
             }
         }
diff --git a/src/TaskManager/Plug-ins/Podman/ContainerVolumeMount.cs b/src/TaskManager/Plug-ins/Podman/ContainerVolumeMount.cs
@@ -14,8 +14,6 @@
  * limitations under the License.
  */
 
-using Ardalis.GuardClauses;
-
 namespace Monai.Deploy.WorkflowManager.TaskManager.Podman
 {
     public class ContainerVolumeMount
diff --git a/src/TaskManager/Plug-ins/Podman/IPodmanContainerCreator.cs b/src/TaskManager/Plug-ins/Podman/IPodmanContainerCreator.cs
@@ -65,6 +65,7 @@ public async Task<PodmanCreateContainerResponse> CreateContainerAsync(Uri podman
             var json = JsonSerializer.Serialize(request, s_jsonOptions);
             using var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
 
+            // The path targets the libpod API at v4.0.0 — the minimum supported Podman version for CDI device support.
             using var response = await httpClient.PostAsync("/v4.0.0/libpod/containers/create", content, cancellationToken).ConfigureAwait(false);
             var responseBody = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
 
diff --git a/src/TaskManager/Plug-ins/Podman/Keys.cs b/src/TaskManager/Plug-ins/Podman/Keys.cs
@@ -19,7 +19,7 @@ namespace Monai.Deploy.WorkflowManager.TaskManager.Podman
     internal static class Keys
     {
         /// <summary>
-        /// Key for the endpoint where the Docker server is running.
+        /// Key for the endpoint where the Podman server is running.
         /// </summary>
         public static readonly string BaseUrl = "server_url";
 
@@ -34,7 +34,7 @@ internal static class Keys
         public static readonly string EntryPoint = "entrypoint";
 
         /// <summary>
-        /// Key for specifying the user to the container. Same as -u argument for docker run.
+        /// Key for specifying the user to the container. Same as -u argument for podman run.
         /// </summary>
         public static readonly string User = "user";
 
@@ -59,7 +59,7 @@ internal static class Keys
         public static readonly string TemporaryStorageContainerPath = "temp_storage_container_path";
 
         /// <summary>
-        /// Prefix for envrionment variables.
+        /// Prefix for environment variables.
         /// </summary>
         public static readonly string EnvironmentVariableKeyPrefix = "env_";
 
@@ -79,7 +79,7 @@ internal static class Keys
         public static readonly string DefaultGpuDevice = "nvidia.com/gpu=all";
 
         /// <summary>
-        /// Required arguments to run the Docker workflow.
+        /// Required arguments to run the Podman workflow.
         /// </summary>
         public static readonly IReadOnlyList<string> RequiredParameters =
             new List<string> {
diff --git a/src/TaskManager/Plug-ins/Podman/Logging/Log.cs b/src/TaskManager/Plug-ins/Podman/Logging/Log.cs
@@ -38,16 +38,16 @@ public static partial class Log
         [LoggerMessage(EventId = 1005, Level = LogLevel.Information, Message = "Podman container terminated: container Id={containerId}.")]
         public static partial void TerminatedContainer(this ILogger logger, string containerId);
 
-        [LoggerMessage(EventId = 1006, Level = LogLevel.Information, Message = "Input volume mapping host=={hostPath}, container={containerPath}.")]
-        public static partial void DockerInputMapped(this ILogger logger, string hostPath, string containerPath);
+        [LoggerMessage(EventId = 1006, Level = LogLevel.Information, Message = "Input volume mapping host={hostPath}, container={containerPath}.")]
+        public static partial void PodmanInputMapped(this ILogger logger, string hostPath, string containerPath);
 
-        [LoggerMessage(EventId = 1007, Level = LogLevel.Information, Message = "Output volume mapping host=={hostPath}, container={containerPath}.")]
-        public static partial void DockerOutputMapped(this ILogger logger, string hostPath, string containerPath);
+        [LoggerMessage(EventId = 1007, Level = LogLevel.Information, Message = "Output volume mapping host={hostPath}, container={containerPath}.")]
+        public static partial void PodmanOutputMapped(this ILogger logger, string hostPath, string containerPath);
 
-        [LoggerMessage(EventId = 1008, Level = LogLevel.Information, Message = "Environment variabled added {key}={value}.")]
-        public static partial void DockerEnvironmentVariableAdded(this ILogger logger, string key, string value);
+        [LoggerMessage(EventId = 1008, Level = LogLevel.Information, Message = "Environment variable added {key}.")]
+        public static partial void PodmanEnvironmentVariableAdded(this ILogger logger, string key);
 
-        [LoggerMessage(EventId = 1009, Level = LogLevel.Error, Message = "Error retreiving status from container {identity}.")]
+        [LoggerMessage(EventId = 1009, Level = LogLevel.Error, Message = "Error retrieving status from container {identity}.")]
         public static partial void ErrorGettingStatusFromDocker(this ILogger logger, string identity, Exception ex);
 
         [LoggerMessage(EventId = 1010, Level = LogLevel.Debug, Message = "Downloading artifact {source} to {target}.")]
@@ -62,8 +62,8 @@ public static partial class Log
         [LoggerMessage(EventId = 1013, Level = LogLevel.Warning, Message = "No output volumes configured for the task.")]
         public static partial void NoOutputVolumesConfigured(this ILogger logger);
 
-        [LoggerMessage(EventId = 10014, Level = LogLevel.Information, Message = "Intermediate volume mapping host=={hostPath}, container={containerPath}.")]
-        public static partial void DockerIntermediateVolumeMapped(this ILogger logger, string hostPath, string containerPath);
+        [LoggerMessage(EventId = 1014, Level = LogLevel.Information, Message = "Intermediate volume mapping host={hostPath}, container={containerPath}.")]
+        public static partial void PodmanIntermediateVolumeMapped(this ILogger logger, string hostPath, string containerPath);
 
         [LoggerMessage(EventId = 1015, Level = LogLevel.Error, Message = "Error generating volume mounts.")]
         public static partial void ErrorGeneratingVolumeMounts(this ILogger logger, Exception exception);
@@ -114,6 +114,6 @@ public static partial class Log
         public static partial void IntermediateVolumeMountAdded(this ILogger logger, string hostPath, string containerPath);
 
         [LoggerMessage(EventId = 1031, Level = LogLevel.Error, Message = "Error setting directory {path} with permission {user}.")]
-        public static partial void ErrorSettingDirectoryPermission(this ILogger logger, string path, string user);
+        public static partial void ErrorSettingDirectoryPermission(this ILogger logger, Exception exception, string path, string user);
     }
 }
diff --git a/src/TaskManager/Plug-ins/Podman/PodmanPlugin.cs b/src/TaskManager/Plug-ins/Podman/PodmanPlugin.cs
@@ -191,10 +191,13 @@ public override async Task<ExecutionStatus> ExecuteTask(CancellationToken cancel
             try
             {
                 var monitor = _scope.ServiceProvider.GetService<IContainerStatusMonitor>() ?? throw new ServiceNotFoundException(nameof(IContainerStatusMonitor));
-                _ = Task.Run(async () =>
+                var monitorTask = Task.Run(async () =>
                 {
-                    await monitor.Start(Event, _containerTimeout, containerId, intermediateVolumeMount, outputVolumeMounts, cancellationToken);
+                    await monitor.Start(Event, _containerTimeout, containerId, intermediateVolumeMount, outputVolumeMounts, CancellationToken.None);
                 });
+                _ = monitorTask.ContinueWith(
+                    t => _logger.ErrorLaunchingContainerMonitor(containerId, t.Exception!.GetBaseException()),
+                    TaskContinuationOptions.OnlyOnFaulted);
             }
             catch (Exception exception)
             {
@@ -244,10 +247,32 @@ public override async Task<ExecutionStatus> GetStatus(string identity, TaskCallb
                 var stats = GetExecutuionStats(response);
                 if (ContainerStatusMonitor.IsContainerCompleted(response.State))
                 {
+                    if (response.State.OOMKilled || response.State.Dead)
+                    {
+                        return new ExecutionStatus
+                        {
+                            Status = TaskExecutionStatus.Failed,
+                            FailureReason = FailureReason.ExternalServiceError,
+                            Errors = $"Exit code={response.State.ExitCode}",
+                            Stats = stats
+                        };
+                    }
+
+                    if (response.State.ExitCode == 0)
+                    {
+                        return new ExecutionStatus
+                        {
+                            Status = TaskExecutionStatus.Succeeded,
+                            FailureReason = FailureReason.None,
+                            Stats = stats
+                        };
+                    }
+
                     return new ExecutionStatus
                     {
-                        Status = TaskExecutionStatus.Succeeded,
-                        FailureReason = FailureReason.None,
+                        Status = TaskExecutionStatus.Failed,
+                        FailureReason = FailureReason.Unknown,
+                        Errors = $"Exit code={response.State.ExitCode}. Status={response.State.Status}.",
                         Stats = stats
                     };
                 }
@@ -334,7 +359,7 @@ private PodmanCreateContainerRequest BuildContainerSpecification(IList<Container
                     Source = input.HostPath,
                     Options = new List<string> { "rbind", "ro" }
                 });
-                _logger.DockerInputMapped(input.HostPath, input.ContainerPath);
+                _logger.PodmanInputMapped(input.HostPath, input.ContainerPath);
             }
 
             foreach (var output in outputs)
@@ -346,7 +371,7 @@ private PodmanCreateContainerRequest BuildContainerSpecification(IList<Container
                     Source = output.HostPath,
                     Options = new List<string> { "rbind", "rw" }
                 });
-                _logger.DockerOutputMapped(output.HostPath, output.ContainerPath);
+                _logger.PodmanOutputMapped(output.HostPath, output.ContainerPath);
             }
 
             if (intermediateVolumeMount is not null)
@@ -358,7 +383,7 @@ private PodmanCreateContainerRequest BuildContainerSpecification(IList<Container
                     Source = intermediateVolumeMount.HostPath,
                     Options = new List<string> { "rbind", "rw" }
                 });
-                _logger.DockerIntermediateVolumeMapped(intermediateVolumeMount.HostPath, intermediateVolumeMount.ContainerPath);
+                _logger.PodmanIntermediateVolumeMapped(intermediateVolumeMount.HostPath, intermediateVolumeMount.ContainerPath);
             }
 
             var envvars = new Dictionary<string, string>();
@@ -369,7 +394,7 @@ private PodmanCreateContainerRequest BuildContainerSpecification(IList<Container
                 {
                     var envVarKey = key.Replace(Keys.EnvironmentVariableKeyPrefix, string.Empty);
                     envvars[envVarKey] = Event.TaskPluginArguments[key];
-                    _logger.DockerEnvironmentVariableAdded(envVarKey, Event.TaskPluginArguments[key]);
+                    _logger.PodmanEnvironmentVariableAdded(envVarKey);
                 }
             }
 
@@ -449,9 +474,10 @@ private async Task<List<ContainerVolumeMount>> SetupInputs(CancellationToken can
                     Directory.CreateDirectory(fileDirectory!);
 
                     _logger.DownloadingArtifactFromStorageService(obj.Filename, filePath);
-                    using var stream = await storageService.GetObjectAsync(input.Bucket, obj.FilePath, cancellationToken).ConfigureAwait(false) as MemoryStream;
+                    using var stream = await storageService.GetObjectAsync(input.Bucket, obj.FilePath, cancellationToken).ConfigureAwait(false)
+                        ?? throw new InvalidOperationException($"Unable to download '{obj.FilePath}' from bucket '{input.Bucket}'.");
                     using var fileStream = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write);
-                    stream!.WriteTo(fileStream);
+                    await stream.CopyToAsync(fileStream, cancellationToken).ConfigureAwait(false);
                 }
             }
 
@@ -520,8 +546,9 @@ private void SetPermission(string path)
 
                     if (process.ExitCode != 0)
                     {
-                        _logger.ErrorSettingDirectoryPermission(path, Event.TaskPluginArguments[Keys.User]);
-                        throw new SetPermissionException($"chown command exited with code {process.ExitCode}");
+                        var permissionException = new SetPermissionException($"chown command exited with code {process.ExitCode}");
+                        _logger.ErrorSettingDirectoryPermission(permissionException, path, Event.TaskPluginArguments[Keys.User]);
+                        throw permissionException;
                     }
                 }
             }
diff --git a/tests/UnitTests/TaskManager.Podman.Tests/ContainerStatusMonitorTest.cs b/tests/UnitTests/TaskManager.Podman.Tests/ContainerStatusMonitorTest.cs
@@ -124,6 +124,32 @@ public async Task Start_WhenCalledWithoutAnyArtifacts_ExpectToSendCallbackEvent(
             _messageBrokerPublisherService.Verify(p => p.Publish(It.IsAny<string>(), It.IsAny<Monai.Deploy.Messaging.Messages.Message>()), Times.Once());
         }
 
+        [Fact(DisplayName = "Start - when upload fails expect callback not to be published")]
+        public async Task Start_WhenUploadFails_ExpectCallbackNotPublished()
+        {
+            var files = new List<string>() { "/taskmanagerpath/output/b.dcm" };
+            CreateFiles(files);
+            var outputVolumeMounts = new List<ContainerVolumeMount>() { new ContainerVolumeMount(new Storage { Bucket = "bucket", RelativeRootPath = "/svc" }, "/containerpath", "/hostpath", "/taskmanagerpath/output") };
+            var monitor = new ContainerStatusMonitor(_serviceScopeFactory.Object, _logger.Object, _fileSystem, _options);
+            var taskDispatchEvent = GenerateTaskDispatchEventWithValidArguments();
+
+            _storageService.Setup(p => p.PutObjectAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Stream>(), It.IsAny<long>(), It.IsAny<string>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<CancellationToken>()))
+                .ThrowsAsync(new Exception("upload error"));
+            _podmanClient.Setup(p => p.Containers.InspectContainerAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(new ContainerInspectResponse
+                {
+                    State = new ContainerState
+                    {
+                        Status = Strings.DockerStatusExited,
+                        FinishedAt = DateTime.MinValue.ToString("s")
+                    }
+                });
+
+            await Assert.ThrowsAsync<Exception>(() => monitor.Start(taskDispatchEvent, TimeSpan.FromSeconds(3), "container", null!, outputVolumeMounts, CancellationToken.None));
+
+            _messageBrokerPublisherService.Verify(p => p.Publish(It.IsAny<string>(), It.IsAny<Monai.Deploy.Messaging.Messages.Message>()), Times.Never());
+        }
+
         [Fact(DisplayName = "Start - when called expect to upload artifacts and send callback event")]
         public async Task Start_WhenCalled_ExpectToUploadArtifactsAndSendCallbackEvent()
         {
diff --git a/tests/UnitTests/TaskManager.Podman.Tests/PodmanPluginTest.cs b/tests/UnitTests/TaskManager.Podman.Tests/PodmanPluginTest.cs

Original file line number	Diff line number	Diff line change
`@@ -84,6 +84,7 @@ public async Task Start(`
`84`	`84`	`var pollingPeriod = TimeSpan.FromSeconds(1);`
`85`	`85`
`86`	`86`	`var timeToRetry = (int)containerTimeout.TotalSeconds;`
	`87`	`+ var completed = false;`
`87`	`88`	`while (timeToRetry-- > 0)`
`88`	`89`	`{`
`89`	`90`	`try`
`@@ -92,22 +93,43 @@ public async Task Start(`
`92`	`93`
`93`	`94`	`if (IsContainerCompleted(response.State))`
`94`	`95`	`{`
`95`		`- await UploadOutputArtifacts(intermediateVolumeMount, outputVolumeMounts, cancellationToken).ConfigureAwait(false);`
`96`		`- await SendCallbackMessage(taskDispatchEvent, containerId).ConfigureAwait(false);`
`97`		`- return;`
	`96`	`+ completed = true;`
	`97`	`+ break;`
`98`	`98`	`}`
`99`	`99`	`}`
`100`	`100`	`catch (Exception ex)`
`101`	`101`	`{`
`102`	`102`	`_logger.ErrorMonitoringContainerStatus(containerId, ex);`
`103`	`103`	`}`
`104`		`- finally`
	`104`	`+`
	`105`	`+ await Task.Delay(pollingPeriod, cancellationToken).ConfigureAwait(false);`
	`106`	`+ }`
	`107`	`+`
	`108`	`+ if (completed)`
	`109`	`+ {`
	`110`	`+ try`
`105`	`111`	`{`
`106`		`- await Task.Delay(pollingPeriod, cancellationToken).ConfigureAwait(false);`
	`112`	`+ await UploadOutputArtifacts(intermediateVolumeMount, outputVolumeMounts, cancellationToken).ConfigureAwait(false);`
	`113`	`+ }`
	`114`	`+ catch (Exception ex)`
	`115`	`+ {`
	`116`	`+ _logger.ErrorMonitoringContainerStatus(containerId, ex);`
	`117`	`+ throw;`
`107`	`118`	`}`
`108`		`- }`
`109`	`119`
`110`		`- _logger.TimedOutMonitoringContainerStatus(containerId);`
	`120`	`+ try`
	`121`	`+ {`
	`122`	`+ await SendCallbackMessage(taskDispatchEvent, containerId).ConfigureAwait(false);`
	`123`	`+ }`
	`124`	`+ catch (Exception ex)`
	`125`	`+ {`
	`126`	`+ _logger.ErrorMonitoringContainerStatus(containerId, ex);`
	`127`	`+ }`
	`128`	`+ }`
	`129`	`+ else`
	`130`	`+ {`
	`131`	`+ _logger.TimedOutMonitoringContainerStatus(containerId);`
	`132`	`+ }`
`111`	`133`	`}`
`112`	`134`
`113`	`135`	`internal static bool IsContainerCompleted(ContainerState state)`
`@@ -161,8 +183,13 @@ private async Task UploadOutputArtifacts(IStorageService storageService, IConten`
`161`	`183`	`{`
`162`	`184`	`try`
`163`	`185`	`{`
`164`		`- var objectName = file.Replace(artifactsPath, string.Empty).TrimStart('/');`
`165`		`- objectName = _fileSystem.Path.Combine(destination.RelativeRootPath, objectName);`
	`186`	`+ var relativePart = file.StartsWith(artifactsPath, StringComparison.Ordinal)`
	`187`	`+ ? file.Substring(artifactsPath.Length)`
	`188`	`+ : file;`
	`189`	`+ relativePart = relativePart.TrimStart('/');`
	`190`	`+ var objectName = string.IsNullOrEmpty(destination.RelativeRootPath)`
	`191`	`+ ? relativePart`
	`192`	`+ : destination.RelativeRootPath.TrimEnd('/') + "/" + relativePart;`
`166`	`193`	`_logger.UploadingFile(file, destination.Bucket, objectName);`
`167`	`194`	`if (!contentTypeProvider.TryGetContentType(file, out var contentType))`
`168`	`195`	`{`
`@@ -175,6 +202,7 @@ private async Task UploadOutputArtifacts(IStorageService storageService, IConten`
`175`	`202`	`catch (Exception ex)`
`176`	`203`	`{`
`177`	`204`	`_logger.ErrorUploadingFile(file, ex);`
	`205`	`+ throw;`
`178`	`206`	`}`
`179`	`207`	`}`
`180`	`208`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,6 @@`
`14`	`14`	`* limitations under the License.`
`15`	`15`	`*/`
`16`	`16`
`17`		`-using Ardalis.GuardClauses;`
`18`		`-`
`19`	`17`	`namespace Monai.Deploy.WorkflowManager.TaskManager.Podman`
`20`	`18`	`{`
`21`	`19`	`public class ContainerVolumeMount`
Original file line number	Diff line number	Diff line change
`@@ -191,10 +191,13 @@ public override async Task<ExecutionStatus> ExecuteTask(CancellationToken cancel`
`191`	`191`	`try`
`192`	`192`	`{`
`193`	`193`	`var monitor = _scope.ServiceProvider.GetService<IContainerStatusMonitor>() ?? throw new ServiceNotFoundException(nameof(IContainerStatusMonitor));`
`194`		`- _ = Task.Run(async () =>`
	`194`	`+ var monitorTask = Task.Run(async () =>`
`195`	`195`	`{`
`196`		`- await monitor.Start(Event, _containerTimeout, containerId, intermediateVolumeMount, outputVolumeMounts, cancellationToken);`
	`196`	`+ await monitor.Start(Event, _containerTimeout, containerId, intermediateVolumeMount, outputVolumeMounts, CancellationToken.None);`
`197`	`197`	`});`
	`198`	`+ _ = monitorTask.ContinueWith(`
	`199`	`+ t => _logger.ErrorLaunchingContainerMonitor(containerId, t.Exception!.GetBaseException()),`
	`200`	`+ TaskContinuationOptions.OnlyOnFaulted);`
`198`	`201`	`}`
`199`	`202`	`catch (Exception exception)`
`200`	`203`	`{`
`@@ -244,10 +247,32 @@ public override async Task<ExecutionStatus> GetStatus(string identity, TaskCallb`
`244`	`247`	`var stats = GetExecutuionStats(response);`
`245`	`248`	`if (ContainerStatusMonitor.IsContainerCompleted(response.State))`
`246`	`249`	`{`
	`250`	`+ if (response.State.OOMKilled \|\| response.State.Dead)`
	`251`	`+ {`
	`252`	`+ return new ExecutionStatus`
	`253`	`+ {`
	`254`	`+ Status = TaskExecutionStatus.Failed,`
	`255`	`+ FailureReason = FailureReason.ExternalServiceError,`
	`256`	`+ Errors = $"Exit code={response.State.ExitCode}",`
	`257`	`+ Stats = stats`
	`258`	`+ };`
	`259`	`+ }`
	`260`	`+`
	`261`	`+ if (response.State.ExitCode == 0)`
	`262`	`+ {`
	`263`	`+ return new ExecutionStatus`
	`264`	`+ {`
	`265`	`+ Status = TaskExecutionStatus.Succeeded,`
	`266`	`+ FailureReason = FailureReason.None,`
	`267`	`+ Stats = stats`
	`268`	`+ };`
	`269`	`+ }`
	`270`	`+`
`247`	`271`	`return new ExecutionStatus`
`248`	`272`	`{`
`249`		`- Status = TaskExecutionStatus.Succeeded,`
`250`		`- FailureReason = FailureReason.None,`
	`273`	`+ Status = TaskExecutionStatus.Failed,`
	`274`	`+ FailureReason = FailureReason.Unknown,`
	`275`	`+ Errors = $"Exit code={response.State.ExitCode}. Status={response.State.Status}.",`
`251`	`276`	`Stats = stats`
`252`	`277`	`};`
`253`	`278`	`}`
`@@ -334,7 +359,7 @@ private PodmanCreateContainerRequest BuildContainerSpecification(IList<Container`
`334`	`359`	`Source = input.HostPath,`
`335`	`360`	`Options = new List<string> { "rbind", "ro" }`
`336`	`361`	`});`
`337`		`- _logger.DockerInputMapped(input.HostPath, input.ContainerPath);`
	`362`	`+ _logger.PodmanInputMapped(input.HostPath, input.ContainerPath);`
`338`	`363`	`}`
`339`	`364`
`340`	`365`	`foreach (var output in outputs)`
`@@ -346,7 +371,7 @@ private PodmanCreateContainerRequest BuildContainerSpecification(IList<Container`
`346`	`371`	`Source = output.HostPath,`
`347`	`372`	`Options = new List<string> { "rbind", "rw" }`
`348`	`373`	`});`
`349`		`- _logger.DockerOutputMapped(output.HostPath, output.ContainerPath);`
	`374`	`+ _logger.PodmanOutputMapped(output.HostPath, output.ContainerPath);`
`350`	`375`	`}`
`351`	`376`
`352`	`377`	`if (intermediateVolumeMount is not null)`
`@@ -358,7 +383,7 @@ private PodmanCreateContainerRequest BuildContainerSpecification(IList<Container`
`358`	`383`	`Source = intermediateVolumeMount.HostPath,`
`359`	`384`	`Options = new List<string> { "rbind", "rw" }`
`360`	`385`	`});`
`361`		`- _logger.DockerIntermediateVolumeMapped(intermediateVolumeMount.HostPath, intermediateVolumeMount.ContainerPath);`
	`386`	`+ _logger.PodmanIntermediateVolumeMapped(intermediateVolumeMount.HostPath, intermediateVolumeMount.ContainerPath);`
`362`	`387`	`}`
`363`	`388`
`364`	`389`	`var envvars = new Dictionary<string, string>();`
`@@ -369,7 +394,7 @@ private PodmanCreateContainerRequest BuildContainerSpecification(IList<Container`
`369`	`394`	`{`
`370`	`395`	`var envVarKey = key.Replace(Keys.EnvironmentVariableKeyPrefix, string.Empty);`
`371`	`396`	`envvars[envVarKey] = Event.TaskPluginArguments[key];`
`372`		`- _logger.DockerEnvironmentVariableAdded(envVarKey, Event.TaskPluginArguments[key]);`
	`397`	`+ _logger.PodmanEnvironmentVariableAdded(envVarKey);`
`373`	`398`	`}`
`374`	`399`	`}`
`375`	`400`
`@@ -449,9 +474,10 @@ private async Task<List<ContainerVolumeMount>> SetupInputs(CancellationToken can`
`449`	`474`	`Directory.CreateDirectory(fileDirectory!);`
`450`	`475`
`451`	`476`	`_logger.DownloadingArtifactFromStorageService(obj.Filename, filePath);`
`452`		`- using var stream = await storageService.GetObjectAsync(input.Bucket, obj.FilePath, cancellationToken).ConfigureAwait(false) as MemoryStream;`
	`477`	`+ using var stream = await storageService.GetObjectAsync(input.Bucket, obj.FilePath, cancellationToken).ConfigureAwait(false)`
	`478`	`+ ?? throw new InvalidOperationException($"Unable to download '{obj.FilePath}' from bucket '{input.Bucket}'.");`
`453`	`479`	`using var fileStream = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write);`
`454`		`- stream!.WriteTo(fileStream);`
	`480`	`+ await stream.CopyToAsync(fileStream, cancellationToken).ConfigureAwait(false);`
`455`	`481`	`}`
`456`	`482`	`}`
`457`	`483`
`@@ -520,8 +546,9 @@ private void SetPermission(string path)`
`520`	`546`
`521`	`547`	`if (process.ExitCode != 0)`
`522`	`548`	`{`
`523`		`- _logger.ErrorSettingDirectoryPermission(path, Event.TaskPluginArguments[Keys.User]);`
`524`		`- throw new SetPermissionException($"chown command exited with code {process.ExitCode}");`
	`549`	`+ var permissionException = new SetPermissionException($"chown command exited with code {process.ExitCode}");`
	`550`	`+ _logger.ErrorSettingDirectoryPermission(permissionException, path, Event.TaskPluginArguments[Keys.User]);`
	`551`	`+ throw permissionException;`
`525`	`552`	`}`
`526`	`553`	`}`
`527`	`554`	`}`