port-ocean 0.18.1__tar.gz → 0.18.3__tar.gz

{port_ocean-0.18.1 → port_ocean-0.18.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.18.1
+Version: 0.18.3
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port

{port_ocean-0.18.1 → port_ocean-0.18.3}/integrations/_infra/Makefile

@@ -41,7 +41,7 @@ define deactivate_virtualenv
     fi
 endef
 
-.SILENT: install install/prod install/local-core lint lint/fix run test clean
+.SILENT: install install/prod install/local-core lint lint/fix run test clean seed
 
 install:
 	$(call deactivate_virtualenv) && \
@@ -85,3 +85,11 @@ clean:
 	rm -rf .tox/
 	rm -rf docs/_build
 	rm -rf dist/
+
+seed:
+	@if [ -f "tests/seed_data.py" ]; then \
+		$(ACTIVATE) && python tests/seed_data.py; \
+	else \
+		echo "No seeding script found. Create tests/seed_data.py for this integration if needed."; \
+		exit 0; \
+	fi

{port_ocean-0.18.1 → port_ocean-0.18.3}/port_ocean/clients/port/client.py

@@ -5,6 +5,7 @@ from port_ocean.clients.port.mixins.blueprints import BlueprintClientMixin
 from port_ocean.clients.port.mixins.entities import EntityClientMixin
 from port_ocean.clients.port.mixins.integrations import IntegrationClientMixin
 from port_ocean.clients.port.mixins.migrations import MigrationClientMixin
+from port_ocean.clients.port.mixins.organization import OrganizationClientMixin
 from port_ocean.clients.port.types import (
     KafkaCreds,
 )
@@ -21,6 +22,7 @@ class PortClient(
     IntegrationClientMixin,
     BlueprintClientMixin,
     MigrationClientMixin,
+    OrganizationClientMixin,
 ):
     def __init__(
         self,
@@ -48,6 +50,7 @@ class PortClient(
         )
         BlueprintClientMixin.__init__(self, self.auth, self.client)
         MigrationClientMixin.__init__(self, self.auth, self.client)
+        OrganizationClientMixin.__init__(self, self.auth, self.client)
 
     async def get_kafka_creds(self) -> KafkaCreds:
         logger.info("Fetching organization kafka credentials")

{port_ocean-0.18.1 → port_ocean-0.18.3}/port_ocean/clients/port/mixins/integrations.py

@@ -1,16 +1,25 @@
-from typing import Any, TYPE_CHECKING, Optional, TypedDict
+import asyncio
+from typing import Any, Dict, TYPE_CHECKING, Optional, TypedDict
 from urllib.parse import quote_plus
 
 import httpx
 from loguru import logger
 from port_ocean.clients.port.authentication import PortAuthentication
 from port_ocean.clients.port.utils import handle_status_code
+from port_ocean.exceptions.port_defaults import DefaultsProvisionFailed
 from port_ocean.log.sensetive import sensitive_log_filter
 
 if TYPE_CHECKING:
     from port_ocean.core.handlers.port_app_config.models import PortAppConfig
 
 
+INTEGRATION_POLLING_INTERVAL_INITIAL_SECONDS = 3
+INTEGRATION_POLLING_INTERVAL_BACKOFF_FACTOR = 1.15
+INTEGRATION_POLLING_RETRY_LIMIT = 30
+CREATE_RESOURCES_PARAM_NAME = "integration_modes"
+CREATE_RESOURCES_PARAM_VALUE = ["create_resources"]
+
+
 class LogAttributes(TypedDict):
     ingestUrl: str
 
@@ -50,12 +59,41 @@ class IntegrationClientMixin:
             self._log_attributes = response["logAttributes"]
         return self._log_attributes
 
+    async def _poll_integration_until_default_provisioning_is_complete(
+        self,
+    ) -> Dict[str, Any]:
+        attempts = 0
+        current_interval_seconds = INTEGRATION_POLLING_INTERVAL_INITIAL_SECONDS
+
+        while attempts < INTEGRATION_POLLING_RETRY_LIMIT:
+            logger.info(
+                f"Fetching created integration and validating config, attempt {attempts+1}/{INTEGRATION_POLLING_RETRY_LIMIT}",
+                attempt=attempts,
+            )
+            response = await self._get_current_integration()
+            integration_json = response.json()
+            if integration_json.get("integration", {}).get("config", {}):
+                return integration_json
+
+            logger.info(
+                f"Integration config is still being provisioned, retrying in {current_interval_seconds} seconds"
+            )
+            await asyncio.sleep(current_interval_seconds)
+
+            attempts += 1
+            current_interval_seconds = int(
+                current_interval_seconds * INTEGRATION_POLLING_INTERVAL_BACKOFF_FACTOR
+            )
+
+        raise DefaultsProvisionFailed(INTEGRATION_POLLING_RETRY_LIMIT)
+
     async def create_integration(
         self,
         _type: str,
         changelog_destination: dict[str, Any],
         port_app_config: Optional["PortAppConfig"] = None,
-    ) -> dict:
+        create_port_resources_origin_in_port: Optional[bool] = False,
+    ) -> Dict[str, Any]:
         logger.info(f"Creating integration with id: {self.integration_identifier}")
         headers = await self.auth.headers()
         json = {
@@ -65,12 +103,26 @@ class IntegrationClientMixin:
             "changelogDestination": changelog_destination,
             "config": {},
         }
-        if port_app_config:
+
+        query_params = {}
+
+        if create_port_resources_origin_in_port:
+            query_params[CREATE_RESOURCES_PARAM_NAME] = CREATE_RESOURCES_PARAM_VALUE
+
+        if port_app_config and not create_port_resources_origin_in_port:
             json["config"] = port_app_config.to_request()
         response = await self.client.post(
-            f"{self.auth.api_url}/integration", headers=headers, json=json
+            f"{self.auth.api_url}/integration",
+            headers=headers,
+            json=json,
+            params=query_params,
         )
         handle_status_code(response)
+        if create_port_resources_origin_in_port:
+            result = (
+                await self._poll_integration_until_default_provisioning_is_complete()
+            )
+            return result["integration"]
         return response.json()["integration"]
 
     async def patch_integration(

port_ocean-0.18.3/port_ocean/clients/port/mixins/organization.py

@@ -0,0 +1,31 @@
+from typing import List
+import httpx
+from loguru import logger
+from port_ocean.clients.port.authentication import PortAuthentication
+from port_ocean.clients.port.utils import handle_status_code
+
+
+class OrganizationClientMixin:
+    def __init__(
+        self,
+        auth: PortAuthentication,
+        client: httpx.AsyncClient,
+    ):
+        self.auth = auth
+        self.client = client
+
+    async def _get_organization_feature_flags(self) -> httpx.Response:
+        logger.info("Fetching organization feature flags")
+
+        response = await self.client.get(
+            f"{self.auth.api_url}/organization",
+            headers=await self.auth.headers(),
+        )
+        return response
+
+    async def get_organization_feature_flags(
+        self, should_raise: bool = True, should_log: bool = True
+    ) -> List[str]:
+        response = await self._get_organization_feature_flags()
+        handle_status_code(response, should_raise, should_log)
+        return response.json().get("organization", {}).get("featureFlags", [])

{port_ocean-0.18.1 → port_ocean-0.18.3}/port_ocean/config/settings.py

@@ -8,7 +8,7 @@ from pydantic.main import BaseModel
 
 from port_ocean.config.base import BaseOceanSettings, BaseOceanModel
 from port_ocean.core.event_listener import EventListenerSettingsType
-from port_ocean.core.models import Runtime
+from port_ocean.core.models import CreatePortResourcesOrigin, Runtime
 from port_ocean.utils.misc import get_integration_name, get_spec_file
 
 LogLevelType = Literal["ERROR", "WARNING", "INFO", "DEBUG", "CRITICAL"]
@@ -68,6 +68,8 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     initialize_port_resources: bool = True
     scheduled_resync_interval: int | None = None
     client_timeout: int = 60
+    # Determines if Port should generate resources such as blueprints and pages instead of ocean
+    create_port_resources_origin: CreatePortResourcesOrigin | None = None
     send_raw_data_examples: bool = True
     port: PortSettings
     event_listener: EventListenerSettingsType = Field(
@@ -101,6 +103,20 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
 
         return values
 
+    @validator("create_port_resources_origin")
+    def validate_create_port_resources_origin(
+        cls, create_port_resources_origin: CreatePortResourcesOrigin | None
+    ) -> CreatePortResourcesOrigin | None:
+        spec = get_spec_file()
+        if spec and spec.get("create_port_resources_origin", None):
+            spec_create_port_resources_origin = spec.get("create_port_resources_origin")
+            if spec_create_port_resources_origin in [
+                CreatePortResourcesOrigin.Port,
+                CreatePortResourcesOrigin.Ocean,
+            ]:
+                return CreatePortResourcesOrigin(spec_create_port_resources_origin)
+        return create_port_resources_origin
+
     @validator("runtime")
     def validate_runtime(cls, runtime: Runtime) -> Runtime:
         if runtime.is_saas_runtime:

{port_ocean-0.18.1 → port_ocean-0.18.3}/port_ocean/core/defaults/initialize.py

@@ -13,12 +13,14 @@ from port_ocean.core.defaults.common import (
     get_port_integration_defaults,
 )
 from port_ocean.core.handlers.port_app_config.models import PortAppConfig
-from port_ocean.core.models import Blueprint
+from port_ocean.core.models import Blueprint, CreatePortResourcesOrigin
 from port_ocean.core.utils.utils import gather_and_split_errors_from_results
 from port_ocean.exceptions.port_defaults import (
     AbortDefaultCreationError,
 )
 
+ORG_USE_PROVISIONED_DEFAULTS_FEATURE_FLAG = "USE_PROVISIONED_DEFAULTS"
+
 
 def deconstruct_blueprints_to_creation_steps(
     raw_blueprints: list[dict[str, Any]],
@@ -54,8 +56,8 @@ def deconstruct_blueprints_to_creation_steps(
 
 async def _initialize_required_integration_settings(
     port_client: PortClient,
-    default_mapping: PortAppConfig,
     integration_config: IntegrationConfiguration,
+    default_mapping: PortAppConfig | None = None,
 ) -> None:
     try:
         logger.info("Initializing integration at port")
@@ -70,6 +72,8 @@ async def _initialize_required_integration_settings(
                 integration_config.integration.type,
                 integration_config.event_listener.get_changelog_destination_details(),
                 port_app_config=default_mapping,
+                create_port_resources_origin_in_port=integration_config.create_port_resources_origin
+                == CreatePortResourcesOrigin.Port,
             )
         elif not integration.get("config"):
             logger.info(
@@ -102,8 +106,10 @@ async def _initialize_required_integration_settings(
 
 async def _create_resources(
     port_client: PortClient,
-    defaults: Defaults,
+    defaults: Defaults | None = None,
 ) -> None:
+    if not defaults:
+        return
     creation_stage, *blueprint_patches = deconstruct_blueprints_to_creation_steps(
         defaults.blueprints
     )
@@ -199,22 +205,64 @@ async def _create_resources(
 async def _initialize_defaults(
     config_class: Type[PortAppConfig], integration_config: IntegrationConfiguration
 ) -> None:
+    if not integration_config.initialize_port_resources:
+        return
+
     port_client = ocean.port_client
     defaults = get_port_integration_defaults(
         config_class, integration_config.resources_path
     )
-    if not defaults:
+
+    if (
+        not integration_config.create_port_resources_origin
+        and integration_config.runtime.is_saas_runtime
+    ):
+        logger.info("Setting resources origin to be Port")
+        integration_config.create_port_resources_origin = CreatePortResourcesOrigin.Port
+
+    if (
+        integration_config.create_port_resources_origin
+        == CreatePortResourcesOrigin.Port
+    ):
+        logger.info(
+            "Resources origin is set to be Port, verifying integration is supported"
+        )
+        org_feature_flags = await port_client.get_organization_feature_flags()
+        if ORG_USE_PROVISIONED_DEFAULTS_FEATURE_FLAG not in org_feature_flags:
+            logger.info(
+                "Port origin for Integration is not supported, changing resources origin to use Ocean"
+            )
+            integration_config.create_port_resources_origin = (
+                CreatePortResourcesOrigin.Ocean
+            )
+
+    if (
+        integration_config.create_port_resources_origin
+        != CreatePortResourcesOrigin.Port
+        and not defaults
+    ):
         logger.warning("No defaults found. Skipping initialization...")
         return None
 
-    if defaults.port_app_config:
+    if (
+        (defaults and defaults.port_app_config)
+        or integration_config.create_port_resources_origin
+        == CreatePortResourcesOrigin.Port
+    ):
         await _initialize_required_integration_settings(
-            port_client, defaults.port_app_config, integration_config
+            port_client,
+            integration_config,
+            defaults.port_app_config if defaults else None,
         )
 
-    if not integration_config.initialize_port_resources:
+    if (
+        integration_config.create_port_resources_origin
+        == CreatePortResourcesOrigin.Port
+    ):
+        logger.info(
+            "Skipping creating defaults resources due to `create_port_resources_origin` being `Port`"
+        )
         return
-
     try:
         logger.info("Found default resources, starting creation process")
         await _create_resources(port_client, defaults)

{port_ocean-0.18.1 → port_ocean-0.18.3}/port_ocean/core/integrations/mixins/sync_raw.py

@@ -143,19 +143,14 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             "combinator": "and",
             "rules": [
                 {
-                    "combinator": "or",
-                    "rules": [
-                        {
-                            "property": "$identifier",
-                            "operator": "in",
-                            "value": [entity.identifier for entity in entities],
-                        },
-                        {
-                            "property": "$blueprint",
-                            "operator": "=",
-                            "value": entities[0].blueprint,
-                        }
-                    ]
+                    "property": "$identifier",
+                    "operator": "in",
+                    "value": [entity.identifier for entity in entities]
+                },
+                {
+                    "property": "$blueprint",
+                    "operator": "=",
+                    "value": entities[0].blueprint
                 }
             ]
         }

{port_ocean-0.18.1 → port_ocean-0.18.3}/port_ocean/core/models.py

@@ -1,11 +1,16 @@
 from dataclasses import dataclass, field
-from enum import Enum
+from enum import Enum, StrEnum
 from typing import Any
 
 from pydantic import BaseModel
 from pydantic.fields import Field
 
 
+class CreatePortResourcesOrigin(StrEnum):
+    Ocean = "Ocean"
+    Port = "Port"
+
+
 class Runtime(Enum):
     Saas = "Saas"
     OnPrem = "OnPrem"

{port_ocean-0.18.1 → port_ocean-0.18.3}/port_ocean/exceptions/port_defaults.py

@@ -14,3 +14,13 @@ class AbortDefaultCreationError(BaseOceanException):
 
 class UnsupportedDefaultFileType(BaseOceanException):
     pass
+
+
+class DefaultsProvisionFailed(BaseOceanException):
+    def __init__(
+        self,
+        retries: int,
+    ):
+        super().__init__(
+            f"Failed to retrieve integration config after {retries} attempts"
+        )

port_ocean-0.18.3/port_ocean/tests/clients/port/mixins/test_organization_mixin.py

@@ -0,0 +1,27 @@
+import pytest
+from unittest.mock import MagicMock, AsyncMock
+
+from port_ocean.clients.port.mixins.organization import OrganizationClientMixin
+
+
+@pytest.fixture
+async def mocked_org_mixin() -> OrganizationClientMixin:
+    auth = MagicMock()
+    auth.headers = AsyncMock()
+    auth.headers.return_value = {"auth": "enticated"}
+    client = MagicMock()
+    client.get = AsyncMock()
+    client.get.return_value = MagicMock()
+    client.get.return_value.json = MagicMock()
+    client.get.return_value.json.return_value = {
+        "organization": {"featureFlags": ["aa", "bb"]}
+    }
+    return OrganizationClientMixin(auth=auth, client=client)
+
+
+async def test_org_feature_flags_should_fetch_proper_json_path(
+    mocked_org_mixin: OrganizationClientMixin,
+) -> None:
+    result = await mocked_org_mixin.get_organization_feature_flags()
+
+    assert result == ["aa", "bb"]

{port_ocean-0.18.1 → port_ocean-0.18.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "port-ocean"
-version = "0.18.1"
+version = "0.18.3"
 description = "Port Ocean is a CLI tool for managing your Port projects."
 readme = "README.md"
 homepage = "https://app.getport.io"