[Container App] Support session pool OnContainerExit lifecycle

src/containerapp/HISTORY.rst

@@ -5,6 +5,7 @@ Release History
 upcoming
 ++++++
 * 'az containerapp session code-interpreter': Fix `--path` in examples
+* 'az containerapp sessionpool': Support `--lifecycle-type` and `--max-alive-period` for session pool creation and update.
 
 1.2.0b3
 ++++++

src/containerapp/azext_containerapp/_params.py

@@ -444,7 +444,9 @@ def load_arguments(self, _):
 
     with self.argument_context('containerapp sessionpool', arg_group='Configuration') as c:
         c.argument('container_type', arg_type=get_enum_type(["CustomContainer", "PythonLTS", "NodeLTS"]), help="The pool type of the Session Pool, default='PythonLTS'")
-        c.argument('cooldown_period', help="Period (in seconds), after which the session will be deleted, default=300")
+        c.argument('lifecycle_type', arg_type=get_enum_type(["Timed", "OnContainerExit"]), help="The lifecycle type of the Session Pool, default='Timed'")
+        c.argument('cooldown_period', help="Period (in seconds), after which the session will be deleted, this is only applicable for lifecycle type 'Timed', default=300")
+        c.argument('max_alive_period', help="Period (in seconds), before the session be deleted if its container was not exited earlier, this is only applicable for lifecycle type 'OnContainerExit', default=3600")
         c.argument('secrets', nargs='*', options_list=['--secrets', '-s'], help="A list of secret(s) for the session pool. Space-separated values in 'key=value' format. Empty string to clear existing values.")
         c.argument('network_status', arg_type=get_enum_type(["EgressEnabled", "EgressDisabled"]), help="Egress is enabled for the Sessions or not.")
 

src/containerapp/azext_containerapp/containerapp_sessionpool_decorator.py

@@ -46,6 +46,11 @@ class ContainerType(Enum):
     NodeLTS = 3
 
 
+class LifecycleType(Enum):
+    Timed = 0
+    OnContainerExit = 1
+
+
 class SessionPoolPreviewDecorator(BaseResource):
     def __init__(self, cmd: AzCliCommand, client: Any, raw_parameters: Dict, models: str):
         super().__init__(cmd, client, raw_parameters, models)
@@ -70,6 +75,18 @@ def get_argument_container_type(self):
     def set_argument_container_type(self, container_type):
         return self.set_param('container_type', container_type)
 
+    def get_argument_lifecycle_type(self):
+        return self.get_param('lifecycle_type')
+
+    def set_argument_lifecycle_type(self, lifecycle_type):
+        return self.set_param('lifecycle_type', lifecycle_type)
+
+    def get_argument_max_alive_period(self):
+        return self.get_param('max_alive_period')
+
+    def set_argument_max_alive_period(self, max_alive_period):
+        return self.set_param('max_alive_period', max_alive_period)
+
     def get_argument_cooldown_period_in_seconds(self):
         return self.get_param('cooldown_period')
 
@@ -160,6 +177,25 @@ def validate_arguments(self):
         else:
             if environment_name is not None:
                 raise ValidationError(f"Do not pass environment name when using container type {container_type}")
+            if self.get_argument_lifecycle_type() is not None and \
+                    self.get_argument_lifecycle_type().lower() != LifecycleType.Timed.name.lower():
+                raise ValidationError(f"The container type {container_type} only supports lifecycle type '{LifecycleType.Timed.name}'.")
+            if self.get_argument_max_alive_period() is not None:
+                raise ValidationError(f"The container type {container_type} does not support --max-alive-period.")
+
+        if self.get_argument_max_alive_period() is not None and \
+                self.get_argument_cooldown_period_in_seconds() is not None:
+            raise ValidationError("--max-alive-period and --cooldown-period cannot be set at the same time.")
+
+        if self.get_argument_max_alive_period() is not None and \
+                self.get_argument_lifecycle_type() is not None and \
+                self.get_argument_lifecycle_type().lower() != LifecycleType.OnContainerExit.name.lower():
+            raise ValidationError(f"--max-alive-period can only be set when --lifecycle-type is '{LifecycleType.OnContainerExit.name}'.")
+
+        if self.get_argument_cooldown_period_in_seconds() is not None and \
+                self.get_argument_lifecycle_type() is not None and \
+                self.get_argument_lifecycle_type().lower() != LifecycleType.Timed.name.lower():
+            raise ValidationError(f"--cooldown-period can only be set when --lifecycle-type is '{LifecycleType.Timed.name}'.")
 
     def construct_payload(self):
         self.session_pool_def["location"] = self.get_argument_location()
@@ -253,12 +289,28 @@ def set_up_managed_identity(self):
             self.session_pool_def["identity"] = identity_def
 
     def set_up_dynamic_configuration(self):
-        if self.get_argument_cooldown_period_in_seconds() is None:
+        if self.get_argument_lifecycle_type() is None:
+            # Auto infer lifecycle type
+            if self.get_argument_cooldown_period_in_seconds() is not None:
+                self.set_argument_lifecycle_type(LifecycleType.Timed.name)
+            elif self.get_argument_max_alive_period() is not None:
+                self.set_argument_lifecycle_type(LifecycleType.OnContainerExit.name)
+            else:
+                # Default to 'Timed'
+                self.set_argument_lifecycle_type(LifecycleType.Timed.name)
+
+        if self.get_argument_lifecycle_type().lower() == LifecycleType.Timed.name.lower() and \
+                self.get_argument_cooldown_period_in_seconds() is None:
             self.set_argument_cooldown_period_in_seconds(300)
 
+        if self.get_argument_lifecycle_type().lower() == LifecycleType.OnContainerExit.name.lower() and \
+                self.get_argument_max_alive_period() is None:
+            self.set_argument_max_alive_period(3600)
+
         dynamic_pool_def = {}
         lifecycle_config_def = {}
-        lifecycle_config_def["lifecycleType"] = "Timed"
+        lifecycle_config_def["lifecycleType"] = self.get_argument_lifecycle_type()
+        lifecycle_config_def["maxAlivePeriodInSeconds"] = self.get_argument_max_alive_period()
         lifecycle_config_def["cooldownPeriodInSeconds"] = self.get_argument_cooldown_period_in_seconds()
         dynamic_pool_def["lifecycleConfiguration"] = lifecycle_config_def
 
@@ -483,11 +535,45 @@ def set_up_managed_identity_settings(self):
             safe_set(self.session_pool_def, "properties", "managedIdentitySettings", value=managed_identity_settings)
 
     def set_up_dynamic_configuration(self):
+        lifecycle_config_def = {}
+
+        # Validate unsupported arguments with a certain lifecycle type
+        if self.get_argument_max_alive_period() is not None and \
+                self.get_argument_lifecycle_type() is not None and \
+                self.get_argument_lifecycle_type().lower() != LifecycleType.OnContainerExit.name.lower():
+            raise ValidationError(f"--max-alive-period can only be set when --lifecycle-type is '{LifecycleType.OnContainerExit.name}'.")
+        if self.get_argument_cooldown_period_in_seconds() is not None and \
+                self.get_argument_lifecycle_type() is not None and \
+                self.get_argument_lifecycle_type().lower() != LifecycleType.Timed.name.lower():
+            raise ValidationError(f"--cooldown-period can only be set when --lifecycle-type is '{LifecycleType.Timed.name}'.")
+
+        # Validate that max_alive_period and cooldown_period are not set at the same time
+        if self.get_argument_max_alive_period() is not None and \
+                self.get_argument_cooldown_period_in_seconds() is not None:
+            raise ValidationError("--max-alive-period and --cooldown-period cannot be set at the same time.")
+
+        # Validate unsupported arguments with existing lifecycle type
+        current_lifecycle_type = safe_get(self.existing_pool_def, "properties", "dynamicPoolConfiguration", "lifecycleConfiguration", "lifecycleType")
+        if self.get_argument_max_alive_period() is not None and \
+                self.get_argument_lifecycle_type() is None and \
+                current_lifecycle_type.lower() != LifecycleType.OnContainerExit.name.lower():
+            raise ValidationError(f"--max-alive-period is not supported for the current --lifecycle-type '{current_lifecycle_type}'.")
+        if self.get_argument_cooldown_period_in_seconds() is not None and \
+                self.get_argument_lifecycle_type() is None and \
+                current_lifecycle_type.lower() != LifecycleType.Timed.name.lower():
+            raise ValidationError(f"--cooldown-period is not supported for the current --lifecycle-type '{current_lifecycle_type}'.")
+
+        if self.get_argument_lifecycle_type() is not None:
+            lifecycle_config_def["lifecycleType"] = self.get_argument_lifecycle_type()
+
         if self.get_argument_cooldown_period_in_seconds() is not None:
-            dynamic_pool_def = {}
-            lifecycle_config_def = {}
-            lifecycle_config_def["lifecycleType"] = "Timed"
             lifecycle_config_def["cooldownPeriodInSeconds"] = self.get_argument_cooldown_period_in_seconds()
+
+        if self.get_argument_max_alive_period() is not None:
+            lifecycle_config_def["maxAlivePeriodInSeconds"] = self.get_argument_max_alive_period()
+
+        if lifecycle_config_def:
+            dynamic_pool_def = {}
             dynamic_pool_def["lifecycleConfiguration"] = lifecycle_config_def
             safe_set(self.session_pool_def, "properties", "dynamicPoolConfiguration", value=dynamic_pool_def)
 

src/containerapp/azext_containerapp/custom.py

@@ -3096,7 +3096,9 @@ def create_session_pool(cmd,
                         location=None,
                         managed_env=None,
                         container_type=None,
+                        lifecycle_type=None,
                         cooldown_period=None,
+                        max_alive_period=None,
                         secrets=None,
                         network_status=None,
                         max_concurrent_sessions=None,
@@ -3135,7 +3137,9 @@ def update_session_pool(cmd,
                         name,
                         resource_group_name,
                         location=None,
+                        lifecycle_type=None,
                         cooldown_period=None,
+                        max_alive_period=None,
                         secrets=None,
                         network_status=None,
                         max_concurrent_sessions=None,