Fix PermissionError on Windows when building durable functions emulator image (#8807)

* dar windows temp issue

* Fix Windows volume mount path for durable emulator container

Use to_posix_path() to convert the emulator data directory path
from Windows-style (D:\a\...) to POSIX-style (/d/a/...) before
passing it as a Docker volume mount key. Docker inside WSL2 cannot
parse Windows paths in volume specifications.

* Fix Windows compatibility: remove emojis, normalize CRLF, fix unit test volume paths

- Remove emoji characters from CLI output in durable_formatters.py and
  durable_callback_handler.py. Windows charmap codec cannot encode Unicode
  emojis, causing 'charmap codec can't encode character' errors.
- Normalize CRLF to LF in integration test stderr comparisons for
  test_execution.py and test_callback.py (Windows outputs \r\n).
- Update unit test volume path assertion to use to_posix_path() matching
  the source code change.
- Update all unit tests referencing the removed emoji strings.

* Fix test Popen encoding for Windows compatibility

Use encoding='utf-8' in start_command_with_streaming Popen call.
On Windows, text=True defaults to cp1252, which silently kills the
output reader thread if any non-cp1252 bytes appear, causing
wait_for_callback_id to time out.

* Revert emoji removal, set PYTHONUTF8=1 in CI workflow instead

Restore all emoji characters in durable CLI output. Instead of removing
them, set PYTHONUTF8=1 in the integration-tests.yml workflow env to
force Python to use UTF-8 on Windows. This makes click.echo handle
emoji correctly without changing the user-facing output.

* 1

* Add debug logging to test_tier1_callback to diagnose Windows failure

* 1

Author: roger-zhangg

.github/workflows/integration-tests.yml

@@ -39,6 +39,7 @@ env:
   NOSE_PARAMETERIZED_NO_WARN: 1
   BY_CANARY: true
   UV_PYTHON: python3.11
+  PYTHONUTF8: 1
   CREDENTIAL_DISTRIBUTION_LAMBDA_ARN: ${{ secrets.CREDENTIAL_DISTRIBUTION_LAMBDA_ARN }}
   ACCOUNT_RESET_LAMBDA_ARN: ${{ secrets.ACCOUNT_RESET_LAMBDA_ARN }}
 

samcli/local/docker/durable_functions_emulator_container.py

@@ -17,7 +17,12 @@
 from samcli.lib.build.utils import _get_host_architecture
 from samcli.lib.clients.lambda_client import DurableFunctionsClient
 from samcli.lib.utils.tar import create_tarball
-from samcli.local.docker.utils import get_tar_filter_for_windows, get_validated_container_client, is_image_current
+from samcli.local.docker.utils import (
+    get_tar_filter_for_windows,
+    get_validated_container_client,
+    is_image_current,
+    to_posix_path,
+)
 
 LOG = logging.getLogger(__name__)
 
@@ -226,10 +231,14 @@ def _build_emulator_image(self):
         # Generate Dockerfile content
         dockerfile_content = self._generate_emulator_dockerfile(emulator_binary_name)
 
-        # Write Dockerfile to temp location and build image
-        with NamedTemporaryFile(mode="w", suffix="_Dockerfile") as dockerfile:
+        # Write Dockerfile to temp location and build image.
+        # Use delete=False because on Windows, NamedTemporaryFile keeps the file
+        # locked while open, preventing tarfile.add() from reading it.
+        dockerfile = NamedTemporaryFile(mode="w", suffix="_Dockerfile", delete=False)
+        try:
             dockerfile.write(dockerfile_content)
             dockerfile.flush()
+            dockerfile.close()
 
             # Prepare tar paths for build context
             tar_paths = {
@@ -248,6 +257,8 @@ def _build_emulator_image(self):
                     return image_tag
                 except Exception as e:
                     raise ClickException(f"Failed to build emulator image: {e}")
+        finally:
+            os.unlink(dockerfile.name)
 
     def _pull_image_if_needed(self):
         """Pull the emulator image if it doesn't exist locally or is out of date."""
@@ -287,7 +298,7 @@ def start(self):
         os.makedirs(emulator_data_dir, exist_ok=True)
 
         volumes = {
-            emulator_data_dir: {"bind": "/tmp/.durable-executions-local", "mode": "rw"},
+            to_posix_path(emulator_data_dir): {"bind": "/tmp/.durable-executions-local", "mode": "rw"},
         }
 
         # Build image with emulator binary

tests/get_testing_resources.py

@@ -45,7 +45,7 @@ def get_testing_credentials(skip_role_deletion=False):
     lambda_client = boto3.client(
         "lambda",
         config=Config(
-            retries={"max_attempts": 0, "mode": "standard"},
+            retries={"max_attempts": 5, "mode": "standard"},
             connect_timeout=LAMBDA_TIME_OUT + 60,
             read_timeout=LAMBDA_TIME_OUT + 60,
         ),

tests/integration/durable_integ_base.py

@@ -126,7 +126,9 @@ def start_command_with_streaming(self, command_list, test_name, env=None, cwd=No
         Returns:
             tuple: (process, output_lines, thread) where output_lines is a list that gets populated as output arrives
         """
-        process = Popen(command_list, stdout=PIPE, stderr=STDOUT, stdin=PIPE, text=True, env=env, cwd=cwd)
+        process = Popen(
+            command_list, stdout=PIPE, stderr=STDOUT, stdin=PIPE, text=True, encoding="utf-8", env=env, cwd=cwd
+        )
         output_lines = []
 
         def log_output():

tests/integration/local/callback/test_callback.py

@@ -1,5 +1,6 @@
 """Integration tests for sam local callback commands - edge cases only."""
 
+import logging
 import re
 from pathlib import Path
 
@@ -11,6 +12,8 @@
 from tests.integration.durable_function_examples import DurableFunctionExamples
 from tests.testing_utils import run_command
 
+LOG = logging.getLogger(__name__)
+
 
 @pytest.mark.xdist_group(name="durable")
 class TestLocalCallback(DurableIntegBase, InvokeIntegBase):
@@ -41,31 +44,54 @@ def _do_callback_test(self, action, operation_name, callback_type, error_suffix)
         command_list = self.get_invoke_command_list(
             example.function_name, no_event=True, durable_execution_name=execution_name
         )
+        LOG.info("Starting invoke command: %s", " ".join(command_list))
         process, output_lines, thread = self.start_command_with_streaming(
             command_list, f"test_callback_already_completed_{action}"
         )
 
         # Wait for callback ID
+        LOG.info("Waiting for callback ID from streaming output...")
         callback_id = self.wait_for_callback_id(output_lines)
-        self.assertIsNotNone(callback_id, "Failed to get callback ID from output")
+        LOG.info("Callback ID result: %s, output_lines collected: %d", callback_id, len(output_lines))
+        if not callback_id:
+            LOG.error("Failed to get callback ID. Output lines so far: %s", output_lines)
+            # Also capture process state
+            LOG.error("Process poll() = %s", process.poll())
+        self.assertIsNotNone(callback_id, f"Failed to get callback ID from output. Lines: {output_lines}")
 
         # Send first callback to complete the execution
         succeed_command = self.get_callback_command_list("succeed", callback_id, result="test result")
+        LOG.info("Sending first callback: %s", " ".join(succeed_command))
         result = run_command(succeed_command)
-        self.assertEqual(result.process.returncode, 0)
+        stdout_str = result.stdout.decode("utf-8") if isinstance(result.stdout, bytes) else result.stdout
+        stderr_str = result.stderr.decode("utf-8") if isinstance(result.stderr, bytes) else result.stderr
+        LOG.info(
+            "First callback result: returncode=%d, stdout=%s, stderr=%s",
+            result.process.returncode,
+            stdout_str,
+            stderr_str,
+        )
+        self.assertEqual(
+            result.process.returncode, 0, f"First callback failed: stdout={stdout_str}, stderr={stderr_str}"
+        )
 
         # Wait for process to complete and close file handles
+        LOG.info("Waiting for invoke process to complete...")
         process.wait(timeout=30)
         thread.join(timeout=5)
         if process.stdin:
             process.stdin.close()
         if process.stdout:
             process.stdout.close()
+        LOG.info("Invoke process completed with returncode=%d", process.returncode)
 
         # Try to send another callback (should fail)
         second_command = self.get_callback_command_list(action, callback_id)
+        LOG.info("Sending second callback (should fail): %s", " ".join(second_command))
         result = run_command(second_command)
         stderr_str = result.stderr.decode("utf-8") if isinstance(result.stderr, bytes) else result.stderr
+        stderr_str = stderr_str.replace("\r\n", "\n")
+        LOG.info("Second callback result: returncode=%d, stderr=%s", result.process.returncode, stderr_str)
 
         self.assertNotEqual(result.process.returncode, 0)
         expected_pattern = f"Error: An error occurred \\(404\\) when calling the {operation_name} operation: Failed to process callback {callback_type}: Callback .+ {error_suffix}"

tests/integration/local/execution/test_execution.py

@@ -38,6 +38,7 @@ def _do_execution_nonexistent_test(self, command, operation_name):
 
         result = run_command(command_list)
         stderr_str = result.stderr.decode("utf-8") if isinstance(result.stderr, bytes) else result.stderr
+        stderr_str = stderr_str.replace("\r\n", "\n")
 
         self.assertNotEqual(result.process.returncode, 0)
         expected_message = f"Error: An error occurred (404) when calling the {operation_name} operation: Execution {nonexistent_arn} not found\n"
@@ -63,6 +64,7 @@ def test_execution_stop_already_completed(self):
         stop_command = [self.cmd, "local", "execution", "stop", execution_arn]
         result = run_command(stop_command)
         stderr_str = result.stderr.decode("utf-8") if isinstance(result.stderr, bytes) else result.stderr
+        stderr_str = stderr_str.replace("\r\n", "\n")
 
         self.assertNotEqual(result.process.returncode, 0)
         expected_message = f"Error: An error occurred (409) when calling the StopDurableExecution operation: Execution {execution_arn} is already completed\n"

tests/unit/local/docker/test_durable_functions_emulator_container.py

@@ -12,6 +12,7 @@
 from click import ClickException
 
 from samcli.local.docker.durable_functions_emulator_container import DurableFunctionsEmulatorContainer
+from samcli.local.docker.utils import to_posix_path
 
 
 class TestDurableFunctionsEmulatorContainer(TestCase):
@@ -302,9 +303,10 @@ def test_create_container(
             # Verify volumes
             volumes = call_args.kwargs["volumes"]
             expected_data_dir = os.path.join(test_dir, ".durable-executions-local")
-            self.assertIn(expected_data_dir, volumes)
-            self.assertEqual(volumes[expected_data_dir]["bind"], "/tmp/.durable-executions-local")
-            self.assertEqual(volumes[expected_data_dir]["mode"], "rw")
+            expected_volume_key = to_posix_path(expected_data_dir)
+            self.assertIn(expected_volume_key, volumes)
+            self.assertEqual(volumes[expected_volume_key]["bind"], "/tmp/.durable-executions-local")
+            self.assertEqual(volumes[expected_volume_key]["mode"], "rw")
 
             # Verify networking
             self.assertEqual(call_args.kwargs["extra_hosts"], {"host.docker.internal": "host-gateway"})