port-ocean 0.24.22__tar.gz → 0.25.2__tar.gz

{port_ocean-0.24.22 → port_ocean-0.25.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.24.22
+Version: 0.25.2
 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.24.22 → port_ocean-0.25.2}/integrations/_infra/Dockerfile.Deb

@@ -3,6 +3,7 @@ ARG BASE_RUNNER_PYTHON_IMAGE=ghcr.io/port-labs/port-ocean-base-runner:latest
 
 FROM ${BASE_BUILDER_PYTHON_IMAGE} AS base
 
+ARG OCEAN_USER_ID=999
 ARG BUILD_CONTEXT
 ARG BUILDPLATFORM
 
@@ -19,7 +20,7 @@ RUN poetry install --without dev --no-root --no-interaction --no-ansi --no-cache
 
 FROM ${BASE_RUNNER_PYTHON_IMAGE} AS prod
 
-RUN groupadd -r appgroup && useradd -r -g appgroup -m ocean
+RUN groupadd -r appgroup && useradd -r -g appgroup -m -u ${OCEAN_USER_ID} ocean
 
 RUN mkdir -p /tmp/ocean
 
@@ -38,6 +39,7 @@ RUN apt-get update \
         ca-certificates \
         openssl \
         curl \
+        acl \
     && apt-get clean
 
 LABEL INTEGRATION_VERSION=${INTEGRATION_VERSION}
@@ -64,7 +66,8 @@ RUN chmod a+x /app/.venv/bin/ocean
 
 RUN chmod a+x /app/init.sh
 RUN ln -s /app/.venv/bin/ocean /usr/bin/ocean
-
+# Add ocean user to ssl certs group
+RUN setfacl -m u:ocean:rwX /etc/ssl/certs
 USER ocean
 # Run the application
 CMD ["bash", "/app/init.sh"]

{port_ocean-0.24.22 → port_ocean-0.25.2}/integrations/_infra/Dockerfile.local

@@ -2,9 +2,10 @@ ARG BASE_PYTHON_IMAGE=debian:trixie-slim
 # debian:trixie-slim - Python 3.12
 FROM ${BASE_PYTHON_IMAGE}
 
-RUN groupadd -r appgroup && useradd -r -g appgroup -m ocean
+ARG OCEAN_USER_ID=999
+RUN groupadd -r appgroup && useradd -r -g appgroup -m -u ${OCEAN_USER_ID} ocean
 
-RUN mkdir -p /tmp/ocean && chown -R ocean:appgroup /tmp/ocean && chmod -R 755 /tmp/ocean
+RUN mkdir -p /tmp/ocean
 
 
 RUN apt-get update \
@@ -27,6 +28,7 @@ RUN apt-get update \
         build-essential\
         git \
         python3-venv \
+        acl \
     && apt-get clean
 
 ARG BUILD_CONTEXT
@@ -40,7 +42,6 @@ ENV PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
 RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
 
 WORKDIR /app
-USER ocean
 
 COPY . .
 RUN rm -rf .venv-docker ${BUILD_CONTEXT}/.venv-docker
@@ -51,5 +52,11 @@ RUN python3 -m venv ${BUILD_CONTEXT}/.venv-docker
 WORKDIR /app/${BUILD_CONTEXT}
 
 WORKDIR /app
+RUN chown -R ocean:appgroup /app && chmod -R 755 /app
+RUN chown -R ocean:appgroup /app/${BUILD_CONTEXT} && chmod -R 755 /app/${BUILD_CONTEXT}
+RUN chown -R ocean:appgroup /tmp/ocean && chmod -R 755 /tmp/ocean
+# Add ocean user to ssl certs group
+RUN setfacl -m u:ocean:rwX /etc/ssl/certs
+USER ocean
 
 ENTRYPOINT ["./integrations/_infra/entry_local.sh"]

port_ocean-0.25.2/integrations/_infra/README.md

@@ -0,0 +1,30 @@
+# Running the Ocean image locally using vscode / Cursor
+
+In order to run the local image of Ocean you need to follow these steps:
+
+1. Build the image:
+
+    ```bash
+    docker build -f integrations/_infra/Dockerfile.local --build-arg BUILD_CONTEXT=integrations/<integration_type> --platform linux/arm64 -t <my-local-image>:<local> .
+    ```
+
+2. Run the image
+   1. `5678` is the debugpy port mentioned in the `entry_local.sh` file
+   2. `8000` is the port of the Ocean FastAPI server
+   3. the `-v` option mounts your local Ocean directory to the pod, allowing you not to constantly build the image.
+      1. Make sure to run the command from the root directory of the Ocean repository.
+
+    ```bash
+    docker run --rm -it \
+    -v $(pwd):/app \
+    -p 5678:5678 \
+    -p 8000:8000 \
+    -e BUILD_CONTEXT=integrations/<integration_type> \
+    -e OCEAN__PORT__CLIENT_ID=<MY_CLIENT_ID> \
+    -e OCEAN__PORT__CLIENT_SECRET=<MY_CLIENT_SECRET> \
+    -e OCEAN__PORT__MY_OTHER_CONFIGURATION=<MY_OTHER_CONFIGURATION> \
+    <my-local-image>:<local>
+    ```
+
+3. In vscode/Cursor, run the `Attach to docker fake-integration integration` Running configuration from the `launch.json`.
+4. Have fun debugging!

{port_ocean-0.24.22 → port_ocean-0.25.2}/integrations/_infra/entry_local.sh

@@ -22,4 +22,5 @@ fi
 source .venv-docker/bin/activate
 python -m pip install -e ../../
 
-ocean sail
+python -m pip install debugpy
+python -m debugpy --listen 0.0.0.0:5678 --wait-for-client debug.py

{port_ocean-0.24.22 → port_ocean-0.25.2}/port_ocean/core/handlers/entities_state_applier/port/get_related_entities.py

@@ -2,6 +2,8 @@ import asyncio
 from collections import defaultdict
 from itertools import groupby
 
+from loguru import logger
+
 from port_ocean.clients.port.client import PortClient
 from port_ocean.core.models import Entity
 
@@ -37,6 +39,11 @@ async def get_related_entities(
     blueprints_to_relations = defaultdict(list)
     for entity, blueprint in entity_to_blueprint:
         for relation_name, relation in entity.relations.items():
+            if relation_name not in blueprint.relations:
+                logger.warning(
+                    f"Relation {relation_name} found in entity {entity.identifier} but not in blueprint {blueprint.identifier}"
+                )
+                continue
             relation_blueprint = blueprint.relations[relation_name].target
             blueprints_to_relations[relation_blueprint].extend(
                 relation if isinstance(relation, list) else [relation]

{port_ocean-0.24.22 → port_ocean-0.25.2}/port_ocean/core/handlers/entity_processor/jq_entity_processor.py

@@ -1,6 +1,7 @@
 import asyncio
 from asyncio import Task
 from dataclasses import dataclass, field
+
 from functools import lru_cache
 from typing import Any, Optional
 import jq  # type: ignore
@@ -23,6 +24,49 @@ from port_ocean.exceptions.core import EntityProcessorException
 from port_ocean.utils.queue_utils import process_in_queue
 
 
+class ExampleStates:
+    __succeed: list[dict[str, Any]]
+    __errors: list[dict[str, Any]]
+    __max_size: int
+
+    def __init__(self, max_size: int = 0) -> None:
+        """
+        Store two sequences:
+          - succeed: items that succeeded
+          - errors:  items that failed
+        """
+        self.__succeed = []
+        self.__errors = []
+        self.__max_size = max_size
+
+    def add_example(self, succeed: bool, item: dict[str, Any]) -> None:
+        if succeed:
+            self.__succeed.append(item)
+        else:
+            self.__errors.append(item)
+
+    def __len__(self) -> int:
+        """
+        Total number of items (successes + errors).
+        """
+        return len(self.__succeed) + len(self.__errors)
+
+    def get_examples(self, number: int = 0) -> list[dict[str, Any]]:
+        """
+        Return a list of up to number items, taking successes first,
+        """
+        if number <= 0:
+            number = self.__max_size
+        # how many from succeed?
+        s_count = min(number, len(self.__succeed))
+        result = list(self.__succeed[:s_count])
+        # how many more from errors?
+        e_count = number - s_count
+        if e_count > 0:
+            result.extend(self.__errors[:e_count])
+        return result
+
+
 @dataclass
 class MappedEntity:
     """Represents the entity after applying the mapping
@@ -182,11 +226,16 @@ class JQEntityProcessor(BaseEntityProcessor):
             return MappedEntity(
                 mapped_entity,
                 did_entity_pass_selector=should_run,
-                raw_data=data if should_run else None,
+                raw_data=data,
                 misconfigurations=misconfigurations,
             )
 
-        return MappedEntity()
+        return MappedEntity(
+            {},
+            did_entity_pass_selector=False,
+            raw_data=data,
+            misconfigurations={},
+        )
 
     async def _calculate_entity(
         self,
@@ -264,24 +313,26 @@ class JQEntityProcessor(BaseEntityProcessor):
 
         passed_entities = []
         failed_entities = []
-        examples_to_send: list[dict[str, Any]] = []
+        examples_to_send = ExampleStates(send_raw_data_examples_amount)
         entity_misconfigurations: dict[str, str] = {}
         missing_required_fields: bool = False
         entity_mapping_fault_counter: int = 0
-
         for result in calculated_entities_results:
             if len(result.misconfigurations) > 0:
                 entity_misconfigurations |= result.misconfigurations
 
+            if (
+                len(examples_to_send) < send_raw_data_examples_amount
+                and result.raw_data is not None
+            ):
+                examples_to_send.add_example(
+                    result.did_entity_pass_selector, result.raw_data
+                )
+
             if result.entity.get("identifier") and result.entity.get("blueprint"):
                 parsed_entity = Entity.parse_obj(result.entity)
                 if result.did_entity_pass_selector:
                     passed_entities.append(parsed_entity)
-                    if (
-                        len(examples_to_send) < send_raw_data_examples_amount
-                        and result.raw_data is not None
-                    ):
-                        examples_to_send.append(result.raw_data)
                 else:
                     failed_entities.append(parsed_entity)
             else:
@@ -294,20 +345,10 @@ class JQEntityProcessor(BaseEntityProcessor):
             entity_mapping_fault_counter,
         )
 
-        if (
-            not calculated_entities_results
-            and raw_results
-            and send_raw_data_examples_amount > 0
-        ):
-            logger.warning(
-                f"No entities were parsed from {len(raw_results)} raw results, sending raw data examples"
-            )
-            examples_to_send = raw_results[:send_raw_data_examples_amount]
-
-        await self._send_examples(examples_to_send, mapping.kind)
+        await self._send_examples(examples_to_send.get_examples(), mapping.kind)
 
         return CalculationResult(
             EntitySelectorDiff(passed=passed_entities, failed=failed_entities),
             errors,
-            misonfigured_entity_keys=entity_misconfigurations,
+            misconfigured_entity_keys=entity_misconfigurations,
         )