uber-compose 2.1.5b1__tar.gz → 2.1.5b3__tar.gz

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uber-compose
-Version: 2.1.5b1
+Version: 2.1.5b3
 Summary: docker compose testing env orchestrator
 Home-page: https://github.com/ko10ok/uber-compose
 Author: Yuriy Sagitov

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/uber_compose/__init__.py

@@ -1,3 +1,4 @@
+from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
 from uber_compose.core.docker_compose_shell.interface import ProcessExit
 from uber_compose.core.docker_compose_shell.interface import TimeOutCheck
 from uber_compose.core.sequence_run_types import ComposeConfig
@@ -24,6 +25,7 @@ __all__ = (
     'TheUberCompose', 'SystemUberCompose',
     'Environment', 'Service', 'Env', 'OverridenService',
     'CommonJsonCli', 'CommandResult', 'ProcessExit', 'JsonParser', 'json_parser', 'ExecTimeout', 'TimeOutCheck',
+    'ExecLifeCyclePolicy',
     'VedroUberCompose', 'UpHealthPolicy', 'DEFAULT_COMPOSE', 'ComposeConfig', 'DEFAULT_ENV_DESCRIPTION',
     'DEFAULT_ENV_ID',
 )

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/uber_compose/core/docker_compose.py

@@ -112,24 +112,47 @@ class ComposeInstance:
                 # TODO check if need to template migrations
                 #   substituted_cmd = handler.cmd.format(**env_config_instance.env_services_map)
                 substituted_cmd = handler.cmd
-                migrate_result = await self.compose_executor.dc_exec_until_state(
+                migration_result = await self.compose_executor.dc_exec_until_state(
                     target_service, substituted_cmd,
                     kill_before=False,
                     kill_after=False,
                 )
-                if not migrate_result.check_result:
+
+                migration_errors = [error for error in migration_result.stderr.split(b'\n') if error]  # empty or none skips
+                skipper_migration_errors = [
+                    current_error
+                    for current_error in migration_errors
+                    if any(
+                        skip_error in current_error for skip_error in (self.health_policy.skip_migrations_errors or [])
+                    )
+                ]
+
+                for skipped_error in skipper_migration_errors:
+                    self.logger.stage_info(
+                        Text(
+                            f'⚠️Skipping migration error for "{substituted_cmd}" on {target_service}:'
+                            f'\n{skipped_error=}'
+                        )
+                    )
+
+                critical_migration_errors = [
+                    error
+                    for error in migration_errors
+                    if error not in skipper_migration_errors
+                ]
+                if not migration_result.finished or critical_migration_errors:
                     services_status = await self.compose_executor.dc_state()
                     error = Text(f"Can't migrate service {target_service}, with {substituted_cmd}", style=Style.bad).append(
-                        Text(f"\n{migrate_result.stdout=}\n",style=Style.regular)
+                        Text(f"\n{migration_result.stdout=}\n",style=Style.regular)
                     ).append(
-                        Text(f"{migrate_result.stderr=}", style=Style.bad)
+                        Text(f"{migration_result.stderr=}", style=Style.bad)
                     ).append(
                         services_status.as_rich_text()
                     )
                     self.logger.error(error)
                     self.logger.error_details(f"\nServices logs:\n {await self.logs(services)}")
                     raise ServicesUpError(f"Can't migrate service {target_service}, with {substituted_cmd}"
-                                          f"\n{migrate_result.stdout=}\n{migrate_result.stderr=}"
+                                          f"\n{migration_result.stdout=}\n{migration_result.stderr=}"
                                           f"\nServices status:\n {services_status.as_rich_text()}") from None
 
     async def run_services_pack(self, services: list[str], migrations):

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/uber_compose/core/docker_compose_shell/interface.py

@@ -315,10 +315,9 @@ class ComposeShellInterface:
         self.logger.stage_debug(stderr.decode('utf-8'))
 
     class ExecResult(NamedTuple):
-        check_result: bool
-        err: OperationError | None = None
         stdout: str = ''
         stderr: str = ''
+        finished: bool = False
 
     async def dc_exec_until_state(self, container: str,
                                   cmd: str,
@@ -343,7 +342,7 @@ class ComposeShellInterface:
         if kill_before:
             await self.dc_exec(container, f'killall {cmd_name}')
 
-        check_done_result = True
+        check_finished_result = True
         if cmd.endswith('&'):
             self.logger.stage_details(f'Command {cmd} is detached-mode running, skipping any finish checks')
             cmd = cmd[:-1]
@@ -353,39 +352,50 @@ class ComposeShellInterface:
                                                     detached=(wait != ProcessExit()))
 
         if isinstance(result, OperationError):
-            check_done_result = False
+            self.logger.stage_details(Text(f'Running command "{cmd}" leads to error:\n {result}', style=Style.info))
+            check_finished_result = False
 
         if wait == ProcessExit():
-            self.logger.stage_info(Text('Retrieving process IDs wait completion', style=Style.info))
+            self.logger.stage_info(Text('Retrieving in-container process IDs and wait completion', style=Style.info))
             process_ids = await retry(
                 attempts=timeout.attempts,
                 delay=timeout.delay_s,
                 until=lambda pids: pids != [] and pids != [-1]
             )(self._dc_exec_process_pids)(container, cmd)
             self.logger.stage_debug(f'pids retrieved {process_ids}')
-            if process_ids:
-                if process_ids == [-1]:
-                    self.logger.stage_details(
-                        f'Process:\n{cmd}\nwas not checked for completion due to no "pidof" tool in container'
+            if process_ids == [-1]:
+                self.logger.stage_details(Text(
+                    (
+                        f'Process:\n{cmd}\nwas not checked for completion '
+                        f'due to no "pidof" tool in container {container}'
+                    ),
+                    style=Style.suspicious
+                ))
+                check_finished_result = False
+            elif process_ids:
+                self.logger.error(Text('Process was not completed', style=Style.suspicious))
+                check_finished_result = False
+                if break_on_timeout:
+                    raise ExecWasntSuccesfullyDone(
+                        f'\nProcess\n{cmd}\nwas not finished in {timeout.attempts}x'
+                        f'{timeout.delay_s} seconds'
                     )
-                else:
-                    self.logger.error(Text('Process was not completed', style=Style.suspicious))
-                    check_done_result = False
-                    if break_on_timeout:
-                        raise ExecWasntSuccesfullyDone(
-                            f'\nProcess\n{cmd}\nwas not finished in {timeout.attempts}x'
-                            f'{timeout.delay_s} seconds'
-                        )
+            else:
+                check_finished_result = True
         elif isinstance(wait, Callable):
             if asyncio.iscoroutinefunction(wait):
-                check_done_result = await wait(container, cmd, env, extra_env, break_on_timeout)
+                check_finished_result = await wait(container, cmd, env, extra_env, break_on_timeout)
             else:
-                check_done_result = wait(container, cmd, env, extra_env, break_on_timeout)
+                check_finished_result = wait(container, cmd, env, extra_env, break_on_timeout)
 
         if kill_after:
             await self.dc_exec(container, f'killall {cmd_name}')
 
-        return ComposeShellInterface.ExecResult(check_done_result, err=result, stdout=stdout, stderr=stderr)
+        return ComposeShellInterface.ExecResult(
+            stdout=stdout,
+            stderr=stderr,
+            finished=check_finished_result,
+        )
 
     @retry(attempts=3, delay=1, until=lambda x: x == JobResult.BAD)
     async def dc_down(self, services: list[str], env: dict = None,

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/uber_compose/core/docker_compose_shell/types.py

@@ -8,6 +8,14 @@ from rich.text import Text
 from uber_compose.output.styles import Style
 
 
+@dataclass
+class ExecLifeCyclePolicy:
+    """Policy for skipping phases of command execution life cycle to reduce time consumption."""
+    kill_before_same_old_command_running: bool = True
+    kill_after_command_still_running: bool = True
+    break_on_timeout: bool = True
+
+
 class ComposeState:
     RUNNING = 'running'
     EXITED = 'exited'

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/uber_compose/helpers/health_policy.py

@@ -9,3 +9,5 @@ class UpHealthPolicy:
     service_up_check_delay_s: int = 3
 
     pre_check_delay_s: float = 0
+
+    skip_migrations_errors: list[bytes] = None

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/uber_compose/uber_compose.py

@@ -1,10 +1,12 @@
 import shlex
 from dataclasses import dataclass
+from typing import Any
 from typing import Callable
 from uuid import uuid4
 
 from rich.text import Text
 
+from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
 from uber_compose.core.docker_compose_shell.interface import TimeOutCheck
 from uber_compose.core.docker_compose_shell.types import ServicesComposeState
 
@@ -174,9 +176,10 @@ class SystemUberCompose:
                    container: str,
                    command: str,
                    extra_env: dict[str, str] = None,
-                   wait: Callable | ProcessExit | None = ProcessExit(),
+                   wait: Callable[..., bool] | ProcessExit | None = ProcessExit(),
                    env_id: str = DEFAULT_ENV_ID,
                    timeout: TimeOutCheck = None,
+                   life_cycle_policy: ExecLifeCyclePolicy = ExecLifeCyclePolicy()
                    ) -> ExecResult | ExecTimeout:
         uid = str(uuid4())
         log_file = f'{uid}.log'
@@ -196,13 +199,22 @@ class SystemUberCompose:
         container = service_state.get_any().labels[Label.SERVICE_NAME]
 
         cmd = f'sh -c \'{shlex.quote(command)[1:-1]} > /tmp/{log_file} 2>&1\''
-        res = await dc_shell.dc_exec_until_state(container, cmd, extra_env=extra_env, wait=wait, timeout=timeout)
+        res = await dc_shell.dc_exec_until_state(
+            container=container,
+            cmd=cmd,
+            extra_env=extra_env,
+            wait=wait,
+            timeout=timeout,
+            kill_before=life_cycle_policy.kill_before_same_old_command_running,
+            kill_after=life_cycle_policy.kill_after_command_still_running,
+            break_on_timeout=life_cycle_policy.break_on_timeout,
+        )
 
         job_result, stdout, stderr = await dc_shell.dc_exec(container, f'cat /tmp/{log_file}')
         if job_result != JobResult.GOOD:
             self.logger.error(Text(f'Error executing command in container {container}: {stderr}'))
 
-        if not res.check_result:
+        if not res.finished:
             return ExecTimeout(stdout=stdout, cmd=command)
 
         return ExecResult(stdout=stdout, cmd=command)

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/uber_compose/vedro_plugin/base_structures/common_json_cli.py

@@ -9,6 +9,7 @@ from typing import Type
 from typing import TypeVar
 from warnings import warn
 
+from uber_compose.core.docker_compose_shell.types import ExecLifeCyclePolicy
 from uber_compose.helpers.exec_result import ExecResult
 
 from uber_compose.core.docker_compose_shell.interface import TimeOutCheck
@@ -214,12 +215,14 @@ class CommonJsonCli(Generic[TCommandResult]):
         result_factory: Type[TCommandResult] = CommandResult,
         cli_client: SystemUberCompose = None,
         timeout: TimeOutCheck = TimeOutCheck(attempts=10, delay_s=1),
+        life_cycle_policy: ExecLifeCyclePolicy = ExecLifeCyclePolicy(),
     ):
         self._container = container
         self._cli_client: SystemUberCompose = cli_client or TheUberCompose()
         self._parse_json_logs = parse_json_logs
         self._result_factory = result_factory
         self._timeout = timeout
+        self._life_cycle_policy = life_cycle_policy
 
     def _make_result(self, cmd: str, env: dict[str, str], logs: bytes, **kwargs) -> TCommandResult:
         stdout, stderr = self._parse_json_logs(logs)
@@ -232,6 +235,7 @@ class CommonJsonCli(Generic[TCommandResult]):
                    wait: Callable | ProcessExit | None = ProcessExit(),
                    command_result_extra: dict = None,
                    timeout: TimeOutCheck = None,
+                   life_cycle_policy: ExecLifeCyclePolicy = None,
                    ) -> TCommandResult:
         if command_result_extra is None:
             command_result_extra = {}
@@ -243,12 +247,16 @@ class CommonJsonCli(Generic[TCommandResult]):
             assert self._container is not None, 'No container specified. Container must be specified either in method call or in CommonJsonCli initialization'
             container = self._container
 
+        if life_cycle_policy is None:
+            life_cycle_policy = self._life_cycle_policy
+
         result = await self._cli_client.exec(
             container=container,
             command=command,
             extra_env=extra_env,
             wait=wait,
             timeout=timeout,
+            life_cycle_policy=life_cycle_policy,
         )
 
         return self._make_result(

{uber_compose-2.1.5b1 → uber_compose-2.1.5b3}/uber_compose.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uber-compose
-Version: 2.1.5b1
+Version: 2.1.5b3
 Summary: docker compose testing env orchestrator
 Home-page: https://github.com/ko10ok/uber-compose
 Author: Yuriy Sagitov