Implement ConfigMap and Secret based python packages.

Author: Patrick J. McNerthney

.gitignore

@@ -209,3 +209,6 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# function-pythonic
+pythonic-packages/

Dockerfile

@@ -1,43 +1,21 @@
-# syntax=docker/dockerfile:1
+FROM python:3.13-slim-trixie AS image
 
-# It's important that this is Debian 12 to match the distroless image.
-FROM debian:12-slim AS build
-
-#RUN --mount=type=cache,target=/var/lib/apt/lists \
-#    --mount=type=cache,target=/var/cache/apt \
-RUN \
-    rm -f /etc/apt/apt.conf.d/docker-clean \
-    && apt-get update \
-    && apt-get install --no-install-recommends --yes python3-venv git
-
-# Don't write .pyc bytecode files. These speed up imports when the program is
-# loaded. There's no point doing that in a container where they'll never be
-# persisted across restarts.
-ENV PYTHONDONTWRITEBYTECODE=true
-
-# Use Hatch to build a wheel. The build stage must do this in a venv because
-# Debian doesn't have a hatch package, and it won't let you install one globally
-# using pip.
-WORKDIR /build
-#RUN --mount=target=. \
-#    --mount=type=cache,target=/root/.cache/pip \
-COPY . /build
-RUN \
-    python3 -m venv /venv/build \
-    && /venv/build/bin/pip install hatch \
-    && /venv/build/bin/hatch build -t wheel /whl
-
-# Create a fresh venv and install only the pythonic wheel into it.
-#RUN --mount=type=cache,target=/root/.cache/pip \
+WORKDIR /root/pythonic
+COPY pyproject.toml /root/pythonic
+COPY crossplane /root/pythonic/crossplane
+WORKDIR /
 RUN \
-    python3 -m venv /venv/fn \
-    && /venv/fn/bin/pip install /whl/*.whl
+  set -eux && \
+  cd /root/pythonic && \
+  pip install --root-user-action ignore --no-build-isolation setuptools==80.9.0 && \
+  pip install --root-user-action ignore --no-build-isolation . && \
+  pip uninstall --root-user-action ignore --yes setuptools && \
+  cd .. && \
+  rm -rf .cache pythonic && \
+  groupadd --gid 2000 pythonic && \
+  useradd --uid 2000 --gid pythonic --home-dir /opt/pythonic --create-home --shell /usr/sbin/nologin pythonic
 
-# Copy the pythonic venv to our runtime stage. It's important that the path be
-# the same as in the build stage, to avoid shebang paths and symlinks breaking. 
-FROM gcr.io/distroless/python3-debian12 AS image
-WORKDIR /
-USER nonroot:nonroot
-COPY --from=build --chown=nonroot:nonroot /venv/fn /venv/fn
+USER pythonic:pythonic
+WORKDIR /opt/pythonic
 EXPOSE 9443
-ENTRYPOINT ["/venv/fn/bin/pythonic"]
+ENTRYPOINT ["python", "-m", "crossplane.pythonic.main"]

README.md

@@ -181,7 +181,7 @@ The BaseComposite class provides the following fields for manipulating the Compo
 | self.status | Map | The composite desired and observed status, read from observed if not in desired |
 | self.conditions | Conditions | The composite desired and observed conditions, read from observed if not in desired |
 | self.connection | Connection | The composite desired and observed connection detials, read from observed if not in desired |
-| self.results | Results | Returned results on the Composite and optionally on the Claim |
+| self.events | Events | Returned events against the Composite and optionally on the Claim |
 | self.ready | Boolean | The composite desired ready state |
 
 The BaseComposite also provides access to the following Crossplane Function level features:

crossplane/pythonic/__version__.py

@@ -32,7 +32,7 @@ def __init__(self, request, response, logger):
         self.status = Status(self.observed.status, self.desired.status)
         self.conditions = Conditions(observed, self.response)
         self.connection = Connection(observed, desired)
-        self.results = Results(self.response)
+        self.events = Events(self.response)
 
     @property
     def ttl(self):
@@ -384,14 +384,14 @@ def _protobuf_value(self):
             value['lastTransitionTime'] = time.isoformat().replace('+00:00', 'Z')
         return value
 
-    def __call__(self, status=_notset, reason=_notset, message=_notset, claim=_notset):
+    def __call__(self, reason=_notset, message=_notset, status=_notset, claim=_notset):
         self._find_condition(True)
-        if status != _notset:
-            self.status = status
         if reason != _notset:
             self.reason = reason
         if message != _notset:
             self.message = message
+        if status != _notset:
+            self.status = status
         if claim != _notset:
             self.claim = claim
         return self
@@ -514,39 +514,42 @@ def __setitem__(self, key, value):
         self._desired.connection_details[key] = value
 
 
-class Results:
+class Events:
     def __init__(self, response):
         self._results = response.results
 
-    def info(self, message, reason=_notset, claim=_notset):
-        result = Result(self._results.append())
-        result.info = True
-        result.message = message
+    def info(self, reason=_notset, message=_notset, claim=_notset):
+        event = Event(self._results.append())
+        event.info = True
         if reason != _notset:
-            result.reason = reason
+            event.reason = reason
+        if message != _notset:
+            event.message = message
         if claim != _notset:
-            result.claim = claim
-        return result
+            event.claim = claim
+        return event
 
-    def warning(self, message, reason=_notset, claim=_notset):
-        result = Result(self._results.append())
-        result.warning = True
-        result.message = message
+    def warning(self, reason=_notset, message=_notset, claim=_notset):
+        event = Event(self._results.append())
+        event.warning = True
         if reason != _notset:
-            result.reason = reason
+            event.reason = reason
+        if message != _notset:
+            event.message = message
         if claim != _notset:
-            result.claim = claim
-        return result
+            event.claim = claim
+        return event
 
-    def fatal(self, message, reason=_notset, claim=_notset):
-        result = Result(self._results.append())
-        result.fatal = True
-        result.message = message
+    def fatal(self, reason=_notset, message=_notset, claim=_notset):
+        event = Event(self._results.append())
+        event.fatal = True
         if reason != _notset:
-            result.reason = reason
+            event.reason = reason
+        if message != _notset:
+            event.message = message
         if claim != _notset:
-            result.claim = claim
-        return result
+            event.claim = claim
+        return event
 
     def __bool__(self):
         return len(self) > 0
@@ -556,15 +559,15 @@ def __len__(self):
 
     def __getitem__(self, key):
         if key >= len(self._results):
-            return Result()
-        return Result(self._results[ix])
+            return Event()
+        return Event(self._results[ix])
 
     def __iter__(self):
         for ix in range(len(self._results)):
             yield self[ix]
 
 
-class Result:
+class Event:
     def __init__(self, result=None):
         self._result = result
 

crossplane/pythonic/composite.py

@@ -5,6 +5,7 @@
 import builtins
 import importlib
 import inspect
+import sys
 
 import grpc
 import crossplane.function.logging
@@ -32,9 +33,22 @@ def __init__(self, debug=False):
         self.logger = crossplane.function.logging.get_logger()
         self.clazzes = {}
 
+    def invalidate_module(self, module):
+        self.clazzes.clear()
+        if module in sys.modules:
+            del sys.modules[module]
+        importlib.invalidate_caches()
+
     async def RunFunction(
         self, request: fnv1.RunFunctionRequest, _: grpc.aio.ServicerContext
     ) -> fnv1.RunFunctionResponse:
+        try:
+            return await self.run_function(request)
+        except:
+            self.logger.exception('Exception thrown in run fuction')
+            raise
+
+    async def run_function(self, request):
         composite = request.observed.composite.resource
         logger = self.logger.bind(
             apiVersion=composite['apiVersion'],
@@ -70,54 +84,71 @@ async def RunFunction(
                 try:
                     exec(composite, module.__dict__)
                 except Exception as e:
-                    crossplane.function.response.fatal(response, f"Exec exception: {e}")
                     logger.exception('Exec exception')
+                    crossplane.function.response.fatal(response, f"Exec exception: {e}")
                     return response
                 composite = ['<script>', 'Composite']
             else:
                 composite = composite.rsplit('.', 1)
                 if len(composite) == 1:
-                    crossplane.function.response.fatal(response, f"Composite class name does not include module: {composite[0]}")
                     logger.error(f"Composite class name does not include module: {composite[0]}")
+                    crossplane.function.response.fatal(response, f"Composite class name does not include module: {composite[0]}")
                     return response
                 try:
                     module = importlib.import_module(composite[0])
                 except Exception as e:
+                    logger.error(str(e))
                     crossplane.function.response.fatal(response, f"Import module exception: {e}")
-                    logger.exception('Import module exception')
                     return response
             clazz = getattr(module, composite[1], None)
             if not clazz:
-                crossplane.function.response.fatal(response, f"{composite[0]} did not define: {composite[1]}")
                 logger.error(f"{composite[0]} did not define: {composite[1]}")
+                crossplane.function.response.fatal(response, f"{composite[0]} did not define: {composite[1]}")
                 return response
             composite = '.'.join(composite)
             if not inspect.isclass(clazz):
-                crossplane.function.response.fatal(response, f"{composite} is not a class")
                 logger.error(f"{composite} is not a class")
+                crossplane.function.response.fatal(response, f"{composite} is not a class")
                 return response
             if not issubclass(clazz, BaseComposite):
-                crossplane.function.response.fatal(response, f"{composite} is not a subclass of BaseComposite")
                 logger.error(f"{composite} is not a subclass of BaseComposite")
+                crossplane.function.response.fatal(response, f"{composite} is not a subclass of BaseComposite")
                 return response
             self.clazzes[composite] = clazz
 
         try:
             composite = clazz(request, response, logger)
         except Exception as e:
-            crossplane.function.response.fatal(response, f"Instatiate exception: {e}")
             logger.exception('Instatiate exception')
+            crossplane.function.response.fatal(response, f"Instatiate exception: {e}")
             return response
 
         try:
             result = composite.compose()
             if asyncio.iscoroutine(result):
                 await result
         except Exception as e:
-            crossplane.function.response.fatal(response, f"Compose exception: {e}")
             logger.exception('Compose exception')
+            crossplane.function.response.fatal(response, f"Compose exception: {e}")
             return response
 
+        if len(composite.response.requirements.extra_resources):
+            requireds = Map()
+            for name, selector in composite.response.requirements.extra_resources:
+                requireds[name].apiVersion = selector.api_version
+                requireds[name].kind = selector.kind
+                if selector.namespace:
+                    requireds[name].namespace = selector.namespace
+                if selector.match_name:
+                    requireds[name].name = selector.match_name
+                if len(selector.match_labels.labels):
+                    for key, value in selector.match_labels.labels:
+                        requireds[name].labels[key] = value
+            if requireds != composite.context._requireds:
+                composite.context._requireds = requireds
+                logger.debug('Requireds requsted')
+                return response
+
         unknownResources = []
         warningResources = []
         fatalResources = []
@@ -145,32 +176,41 @@ async def RunFunction(
                         elif warning:
                             logger.warning('Observed unknown', destination=destination, source=source)
                         else:
-                            logger.debug('New unknown', destination=destination, source=source)
+                            logger.debug('Desired unknown', destination=destination, source=source)
                 if resource.observed:
                     resource.desired._patchUnknowns(resource.observed)
                 else:
                     del composite.resources[name]
+
         if fatalResources:
-            if not self.debug:
-                logger.error('Observed resources with unknowns', resources=fatalResources)
+            level = logger.error
+            reason = 'FatalUnknowns'
             message = f"Observed resources with unknowns: {','.join(fatalResources)}"
-            composite.conditions.NoUnknowns(False, 'FatalUnknowns', message)
-            composite.results.fatal(message, 'FatalUnknowns')
-            return response
-        if warningResources:
-            if not self.debug:
-                logger.warning('Observed resources with unknowns', resources=fatalResources)
+            status = False
+            event = composite.events.fatal
+        elif warningResources:
+            level = logger.warning
+            reason = 'ObservedUnknowns'
             message = f"Observed resources with unknowns: {','.join(warningResources)}"
-            composite.conditions.NoUnknowns(False, 'ObservedUnknowns', message)
-            composite.results.warning(message, 'ObservedUnknowns')
+            status = False
+            event = composite.events.warning
         elif unknownResources:
-            if not self.debug:
-                logger.info('New resources with unknowns', resources=unknownResources)
-            message = f"New resources with unknowns: {','.join(unknownResources)}"
-            composite.conditions.NoUnknowns(False, 'NewUnknowns', message)
-            composite.results.info(message, 'NewUnknowns')
+            level = logger.info
+            reason = 'DesiredUnknowns'
+            message = f"Desired resources with unknowns: {','.join(unknownResources)}"
+            status = False
+            event = composite.events.info
         else:
-            composite.conditions.NoUnknowns(True, 'AllResolved', 'All resources are resolved')
+            level = None
+            reason = 'AllComposed'
+            message = 'All resources are composed'
+            status = True
+            event = None
+        if not self.debug and level:
+            level(message)
+        composite.conditions.ResourcesComposed(reason, message, status)
+        if event:
+            event(reason, message)
 
         for name, resource in composite.resources:
             if resource.autoReady or (resource.autoReady is None and composite.autoReady):