mlrun 1.10.0rc40__py3-none-any.whl → 1.11.0rc16__py3-none-any.whl

mlrun/runtimes/nuclio/application/application.py

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import copy
 import pathlib
 import typing
 
@@ -20,23 +21,18 @@ import nuclio.auth
 import mlrun.common.schemas as schemas
 import mlrun.errors
 import mlrun.run
-from mlrun.common.runtimes.constants import NuclioIngressAddTemplatedIngressModes
-from mlrun.runtimes import RemoteRuntime
-from mlrun.runtimes.nuclio import (
-    min_nuclio_versions,
-    multiple_port_sidecar_is_supported,
+import mlrun.runtimes.nuclio.api_gateway as nuclio_api_gateway
+import mlrun.runtimes.nuclio.function as nuclio_function
+from mlrun.common.runtimes.constants import (
+    NuclioIngressAddTemplatedIngressModes,
+    ProbeTimeConfig,
+    ProbeType,
 )
-from mlrun.runtimes.nuclio.api_gateway import (
-    APIGateway,
-    APIGatewayMetadata,
-    APIGatewaySpec,
-)
-from mlrun.runtimes.nuclio.function import NuclioSpec, NuclioStatus
 from mlrun.utils import is_valid_port, logger, update_in
 
 
-class ApplicationSpec(NuclioSpec):
-    _dict_fields = NuclioSpec._dict_fields + [
+class ApplicationSpec(nuclio_function.NuclioSpec):
+    _dict_fields = nuclio_function.NuclioSpec._dict_fields + [
         "internal_application_port",
         "application_ports",
     ]
@@ -88,6 +84,7 @@ class ApplicationSpec(NuclioSpec):
         track_models=None,
         internal_application_port=None,
         application_ports=None,
+        auth=None,
     ):
         super().__init__(
             command=command,
@@ -133,6 +130,7 @@ class ApplicationSpec(NuclioSpec):
             track_models=track_models,
             state_thresholds=state_thresholds,
             disable_default_http_trigger=disable_default_http_trigger,
+            auth=auth,
         )
 
         # Override default min/max replicas (don't assume application is stateless)
@@ -189,7 +187,7 @@ class ApplicationSpec(NuclioSpec):
 
         # ensure multiple ports are supported in Nuclio
         if len(application_ports) > 1:
-            multiple_port_sidecar_is_supported()
+            nuclio_function.multiple_port_sidecar_is_supported()
 
         self._application_ports = application_ports
 
@@ -215,7 +213,7 @@ class ApplicationSpec(NuclioSpec):
         self.application_ports = self._application_ports
 
 
-class ApplicationStatus(NuclioStatus):
+class ApplicationStatus(nuclio_function.NuclioStatus):
     def __init__(
         self,
         state=None,
@@ -245,15 +243,17 @@ class ApplicationStatus(NuclioStatus):
         self.application_source = application_source or None
         self.sidecar_name = sidecar_name or None
         self.api_gateway_name = api_gateway_name or None
-        self.api_gateway: typing.Optional[APIGateway] = api_gateway or None
+        self.api_gateway: typing.Optional[nuclio_api_gateway.APIGateway] = (
+            api_gateway or None
+        )
         self.url = url or None
 
 
-class ApplicationRuntime(RemoteRuntime):
+class ApplicationRuntime(nuclio_function.RemoteRuntime):
     kind = "application"
     reverse_proxy_image = None
 
-    @min_nuclio_versions("1.13.1")
+    @nuclio_function.min_nuclio_versions("1.13.1")
     def __init__(self, spec=None, metadata=None):
         super().__init__(spec=spec, metadata=metadata)
 
@@ -278,7 +278,7 @@ class ApplicationRuntime(RemoteRuntime):
         return self.status.api_gateway
 
     @api_gateway.setter
-    def api_gateway(self, api_gateway: APIGateway):
+    def api_gateway(self, api_gateway: nuclio_api_gateway.APIGateway):
         self.status.api_gateway = api_gateway
 
     @property
@@ -294,6 +294,96 @@ class ApplicationRuntime(RemoteRuntime):
     def set_internal_application_port(self, port: int):
         self.spec.internal_application_port = port
 
+    def set_probe(
+        self,
+        type: str,
+        initial_delay_seconds: int | None = None,
+        period_seconds: int | None = None,
+        failure_threshold: int | None = None,
+        timeout_seconds: int | None = None,
+        http_path: str | None = None,
+        http_port: int | None = None,
+        http_scheme: str | None = None,
+        config: dict | None = None,
+    ):
+        """Set a Kubernetes probe configuration for the sidecar container
+
+        The config parameter serves as the base configuration, and individual parameters
+        override values in config. If http_path is provided without http_port and config
+        is not provided, the port will be enriched from the internal application port
+        just before deployment.
+
+        :param type:                 Probe type - one of "readiness", "liveness", "startup"
+        :param initial_delay_seconds: Number of seconds after the container has started before probes are initiated
+        :param period_seconds:         How often (in seconds) to perform the probe
+        :param failure_threshold:     Minimum consecutive failures for the probe to be considered failed
+        :param timeout_seconds:       Number of seconds after which the probe times out
+        :param http_path:            If provided, use an HTTP probe with this path
+        :param http_port:            If HTTP probe is used and no port provided,
+                                     the internal application port will be used
+        :param http_scheme:           "http" or "https" for HTTP probe. Defaults to "http"
+        :param config:                A full dict with the probe configuration
+                                     (used as base, overridden by individual parameters)
+
+        :return: function object (self)
+        """
+        self._validate_set_probes_input(locals())
+        type = ProbeType(type)
+
+        # Start with config as base
+        probe_config = copy.deepcopy(config) if config else {}
+
+        # Build HTTP probe configuration if http_path is provided
+        # Note: If http_path is None, all HTTP-related parameters (http_port, http_scheme) are ignored
+        if http_path:
+            http_probe = probe_config.get("httpGet", {})
+            http_probe["path"] = http_path
+            if http_port is not None:
+                http_probe["port"] = http_port
+            http_probe["scheme"] = http_scheme or http_probe.get("scheme", "HTTP")
+            probe_config["httpGet"] = http_probe
+
+        # Override timing parameters from explicit arguments
+        probe_config.update(
+            {
+                config.value: value
+                for config, value in {
+                    ProbeTimeConfig.INITIAL_DELAY_SECONDS: initial_delay_seconds,
+                    ProbeTimeConfig.PERIOD_SECONDS: period_seconds,
+                    ProbeTimeConfig.FAILURE_THRESHOLD: failure_threshold,
+                    ProbeTimeConfig.TIMEOUT_SECONDS: timeout_seconds,
+                }.items()
+                if value is not None
+            }
+        )
+
+        # Store probe configuration in the sidecar
+        sidecar = self._set_sidecar(self._get_sidecar_name())
+        sidecar[type.key] = probe_config
+
+        return self
+
+    def delete_probe(
+        self,
+        type: str,
+    ):
+        """Delete a Kubernetes probe configuration from the sidecar container
+
+        :param type: Probe type - one of "readiness", "liveness", "startup"
+
+        :return: function object (self)
+        """
+        # Validate probe type
+        ProbeType.is_valid(type, raise_on_error=True)
+        type = ProbeType(type)
+
+        sidecar = self._get_sidecar()
+        if sidecar:
+            if type.key in sidecar:
+                del sidecar[type.key]
+
+        return self
+
     def with_sidecar(
         self,
         name: typing.Optional[str] = None,
@@ -400,7 +490,6 @@ class ApplicationRuntime(RemoteRuntime):
 
         :return: The default API gateway URL if created or True if the function is ready (deployed)
         """
-        mlrun.utils.helpers.validate_function_name(self.metadata.name)
 
         if (self.requires_build() and not self.spec.image) or force_build:
             self._fill_credentials()
@@ -422,6 +511,7 @@ class ApplicationRuntime(RemoteRuntime):
         self.spec.add_templated_ingress_host_mode = (
             NuclioIngressAddTemplatedIngressModes.never
         )
+        self._enrich_sidecar_probe_ports()
 
         super().deploy(
             project=project,
@@ -569,23 +659,23 @@ class ApplicationRuntime(RemoteRuntime):
                 "Authentication credentials not provided"
             )
 
-        if direct_port_access and port:
+        if not direct_port_access and port:
             logger.warning(
-                "Ignoring 'port' because 'direct_port_access' is enabled. "
-                "The 'port' setting is only applicable when 'direct_port_access' is disabled."
+                "Ignoring 'port' because 'direct_port_access' is not enabled. "
+                "The 'port' setting is only applicable when 'direct_port_access' is enabled."
             )
 
         ports = (
             port or self.spec.internal_application_port if direct_port_access else []
         )
 
-        api_gateway = APIGateway(
-            APIGatewayMetadata(
+        api_gateway = nuclio_api_gateway.APIGateway(
+            nuclio_api_gateway.APIGatewayMetadata(
                 name=name,
                 namespace=self.metadata.namespace,
                 labels=self.metadata.labels.copy(),
             ),
-            APIGatewaySpec(
+            nuclio_api_gateway.APIGatewaySpec(
                 functions=[self],
                 project=self.metadata.project,
                 path=path,
@@ -609,6 +699,8 @@ class ApplicationRuntime(RemoteRuntime):
             api_gateway.with_access_key_auth()
         elif authentication_mode == schemas.APIGatewayAuthenticationMode.basic:
             api_gateway.with_basic_auth(*authentication_creds)
+        elif authentication_mode == schemas.APIGatewayAuthenticationMode.iguazio:
+            api_gateway.with_iguazio_auth()
 
         db = self._get_db()
         api_gateway_scheme = db.store_api_gateway(
@@ -617,12 +709,14 @@ class ApplicationRuntime(RemoteRuntime):
 
         if set_as_default:
             self.status.api_gateway_name = api_gateway_scheme.metadata.name
-            self.status.api_gateway = APIGateway.from_scheme(api_gateway_scheme)
+            self.status.api_gateway = nuclio_api_gateway.APIGateway.from_scheme(
+                api_gateway_scheme
+            )
             self.status.api_gateway.wait_for_readiness()
             self.url = self.status.api_gateway.invoke_url
             url = self.url
         else:
-            api_gateway = APIGateway.from_scheme(api_gateway_scheme)
+            api_gateway = nuclio_api_gateway.APIGateway.from_scheme(api_gateway_scheme)
             api_gateway.wait_for_readiness()
             url = api_gateway.invoke_url
             # Update application status (enriches invocation url)
@@ -646,7 +740,7 @@ class ApplicationRuntime(RemoteRuntime):
     def invoke(
         self,
         path: str = "",
-        body: typing.Optional[typing.Union[str, bytes, dict]] = None,
+        body: typing.Optional[typing.Union[str, bytes, dict, list]] = None,
         method: typing.Optional[str] = None,
         headers: typing.Optional[dict] = None,
         force_external_address: bool = False,
@@ -740,7 +834,7 @@ class ApplicationRuntime(RemoteRuntime):
             else self.metadata.name
         )
 
-    @min_nuclio_versions("1.13.1")
+    @nuclio_function.min_nuclio_versions("1.13.1")
     def disable_default_http_trigger(
         self,
     ):
@@ -748,7 +842,7 @@ class ApplicationRuntime(RemoteRuntime):
             "Application runtime does not support disabling the default HTTP trigger"
         )
 
-    @min_nuclio_versions("1.13.1")
+    @nuclio_function.min_nuclio_versions("1.13.1")
     def enable_default_http_trigger(
         self,
     ):
@@ -879,6 +973,80 @@ class ApplicationRuntime(RemoteRuntime):
         api_gateway_scheme = db.get_api_gateway(
             name=self.status.api_gateway_name, project=self.metadata.project
         )
-        self.status.api_gateway = APIGateway.from_scheme(api_gateway_scheme)
+        self.status.api_gateway = nuclio_api_gateway.APIGateway.from_scheme(
+            api_gateway_scheme
+        )
         self.status.api_gateway.wait_for_readiness()
         self.url = self.status.api_gateway.invoke_url
+
+    def _enrich_sidecar_probe_ports(self):
+        """Enrich sidecar probe configurations with internal application port if needed
+
+        This method is called just before deployment to automatically enrich HTTP probes
+        in the sidecar container that were configured without an explicit port.
+
+        Enrichment logic:
+        - Only enriches HTTP probes (httpGet) that don't already have a port specified
+        - If the user explicitly provided http_port in set_probe(), enrichment is skipped
+        - If the user provided a port in the config dict, enrichment is skipped
+        - Enrichment happens just before deployment to ensure the latest internal_application_port
+          value is used, even if it was modified after set_probe() was called
+        """
+        # Check each probe type and enrich missing HTTP ports
+        sidecar = self._get_sidecar()
+        if not sidecar:
+            return
+
+        for probe_type in ProbeType:
+            probe_config = sidecar.get(probe_type.key)
+
+            if probe_config and isinstance(probe_config, dict):
+                http_get = probe_config.get("httpGet")
+                if http_get and isinstance(http_get, dict) and "port" not in http_get:
+                    if self.spec.internal_application_port is None:
+                        raise ValueError(
+                            f"Cannot enrich {probe_type.value} probe: HTTP probe requires a port, "
+                            "but internal_application_port is not set. "
+                            "Please set the internal_application_port or provide http_port in set_probe()."
+                        )
+                    http_get["port"] = self.spec.internal_application_port
+                    logger.debug(
+                        "Enriched sidecar probe port",
+                        probe_type=probe_type.value,
+                        port=http_get["port"],
+                        application_name=self.metadata.name,
+                    )
+                    sidecar[probe_type.key] = probe_config
+
+    def _get_sidecar(self) -> dict | None:
+        """Get the sidecar container for ApplicationRuntime
+
+        Returns the sidecar dict if found, None otherwise.
+        """
+        sidecar_name = self._get_sidecar_name()
+        if not hasattr(self.spec, "config") or "spec.sidecars" not in self.spec.config:
+            return None
+
+        sidecars = self.spec.config["spec.sidecars"]
+        for sidecar in sidecars:
+            if sidecar.get("name") == sidecar_name:
+                return sidecar
+
+        return None
+
+    def _get_sidecar_name(self) -> str:
+        return f"{self.metadata.name}-sidecar"
+
+    @staticmethod
+    def _validate_set_probes_input(params: dict):
+        # Validate probe type
+        ProbeType.is_valid(params.get("type"), raise_on_error=True)
+
+        # At least one optional parameter must be provided
+        optional_params = {
+            k: v for k, v in params.items() if (k != "type" and k != "self")
+        }
+        if all(v is None for v in optional_params.values()):
+            raise ValueError(
+                "Empty probe configuration: at least one parameter must be set"
+            )