crossplane-function-pythonic 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

crossplane/pythonic/grpc.py

@@ -1,5 +1,6 @@
 
 import asyncio
+import logging
 import os
 import pathlib
 import shlex
@@ -10,10 +11,13 @@ import crossplane.function.proto.v1.run_function_pb2_grpc as grpcv1
 import grpc
 
 from . import (
+    __about__,
     command,
     function,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class Command(command.Command):
     name = 'grpc'
@@ -77,13 +81,14 @@ class Command(command.Command):
             pip._internal.cli.main.main(['install', '--user', *shlex.split(self.args.pip_install)])
 
         self.initialize_function()
+        logger.info(f"Version: {__about__.__version__}")
 
         # enables read only volumes or mismatched uid volumes
         sys.dont_write_bytecode = True
 
     async def run(self):
         grpc.aio.init_grpc_aio()
-        grpc_runner = function.FunctionRunner(self.args.debug, self.args.render_unknowns)
+        grpc_runner = function.FunctionRunner(self.args.debug, self.args.render_unknowns, self.args.crossplane_v1)
         grpc_server = grpc.aio.server()
         grpcv1.add_FunctionRunnerServiceServicer_to_server(grpc_runner, grpc_server)
         if self.args.insecure:

crossplane/pythonic/protobuf.py

@@ -58,17 +58,21 @@ def B64Decode(string):
 
 class Message:
     def __init__(self, parent, key, descriptor, message=_Unknown, readOnly=False):
-        self.__dict__['_parent'] = parent
-        self.__dict__['_key'] = key
-        self.__dict__['_descriptor'] = descriptor
-        self.__dict__['_message'] = message
-        self.__dict__['_readOnly'] = readOnly
-        self.__dict__['_cache'] = {}
+        self._set_attribute('_parent', parent)
+        self._set_attribute('_key', key)
+        self._set_attribute('_descriptor', descriptor)
+        self._set_attribute('_message', message)
+        self._set_attribute('_readOnly', readOnly)
+        self._set_attribute('_cache', {})
+
+    def _set_attribute(self, key, value):
+        self.__dict__[key] = value
 
     def __getattr__(self, key):
         return self[key]
 
     def __getitem__(self, key):
+        key = self._validate_key(key)
         if key in self._cache:
             return self._cache[key]
         field = self._descriptor.fields_by_name.get(key)
@@ -156,6 +160,7 @@ class Message:
     def _create_child(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if self._message is _Unknown:
             self.__dict__['_message'] = self._parent._create_child(self._key)
         return getattr(self._message, key)
@@ -177,6 +182,7 @@ class Message:
     def __setitem__(self, key, value):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if key not in self._descriptor.fields_by_name:
             raise AttributeError(obj=self, name=key)
         field = self._descriptor.fields_by_name[key]
@@ -201,26 +207,40 @@ class Message:
     def __delitem__(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if key not in self._descriptor.fields_by_name:
             raise AttributeError(obj=self, name=key)
         if self._message is not _Unknown:
             self._message.ClearField(key)
             self._cache.pop(key, None)
 
+    def _validate_key(self, key):
+        if isinstance(key, FieldMessage):
+            key = key._value
+        elif isinstance(key, Value):
+            key = key._raw
+        if not isinstance(key, str):
+            raise TypeError(f"Unexpected key type: {key.__class__}")
+        return key
+
 
 class MapMessage:
     def __init__(self, parent, key, field, messages=_Unknown, readOnly=False):
-        self.__dict__['_parent'] = parent
-        self.__dict__['_key'] = key
-        self.__dict__['_field'] = field
-        self.__dict__['_messages'] = messages
-        self.__dict__['_readOnly'] = readOnly
-        self.__dict__['_cache'] = {}
+        self._set_attribute('_parent', parent)
+        self._set_attribute('_key', key)
+        self._set_attribute('_field', field)
+        self._set_attribute('_messages', messages)
+        self._set_attribute('_readOnly', readOnly)
+        self._set_attribute('_cache', {})
+
+    def _set_attribute(self, key, value):
+        self.__dict__[key] = value
 
     def __getattr__(self, key):
         return self[key]
 
     def __getitem__(self, key):
+        key = self._validate_key(key)
         if key in self._cache:
             return self._cache[key]
         if self._messages is _Unknown or key not in self._messages:
@@ -304,6 +324,7 @@ class MapMessage:
     def _create_child(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if self._messages is _Unknown:
             self.__dict__['_messages'] = self._parent._create_child(self._key)
         return self._messages[key]
@@ -325,6 +346,7 @@ class MapMessage:
     def __setitem__(self, key, message):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if self._messages is _Unknown:
             self._messages = self._parent._create_child(self._key)
         if isinstance(message, Message):
@@ -349,11 +371,21 @@ class MapMessage:
     def __delitem__(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if self._messages is not _Unknown:
             if key in self._messages:
                 del self._messages[key]
             self._cache.pop(key, None)
 
+    def _validate_key(self, key):
+        if isinstance(key, FieldMessage):
+            key = key._value
+        elif isinstance(key, Value):
+            key = key._raw
+        if not isinstance(key, str):
+            raise TypeError(f"Unexpected key type: {key.__class__}")
+        return key
+
 
 class RepeatedMessage:
     def __init__(self, parent, key, field, messages=_Unknown, readOnly=False):
@@ -365,6 +397,7 @@ class RepeatedMessage:
         self._cache = {}
 
     def __getitem__(self, key):
+        key = self._validate_key(key)
         if key in self._cache:
             return self._cache[key]
         if self._messages is _Unknown or key >= len(self._messages):
@@ -447,6 +480,7 @@ class RepeatedMessage:
     def _create_child(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if self._messages is _Unknown:
             self.__dict__['_messages'] = self._parent._create_child(self._key)
         if key == append:
@@ -471,6 +505,7 @@ class RepeatedMessage:
     def __setitem__(self, key, message):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if self._messages is _Unknown:
             self._messages = self._parent._create_child(self._key)
         if key < 0:
@@ -499,6 +534,7 @@ class RepeatedMessage:
     def __delitem__(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if self._messages is not _Unknown:
             del self._messages[key]
             self._cache.pop(key, None)
@@ -514,41 +550,75 @@ class RepeatedMessage:
             message = self._messages.append(message)
         return self[len(self._messages) - 1]
 
+    def _validate_key(self, key):
+        if isinstance(key, FieldMessage):
+            key = key._value
+        elif isinstance(key, Value):
+            key = key._raw
+        if not isinstance(key, int):
+            raise TypeError(f"Unexpected key type: {key.__class__}")
+        return key
+
 
 class FieldMessage:
     def __init__(self, parent, key, kind, value):
-        self.__dict__['_parent'] = parent
-        self.__dict__['_key'] = key
-        self.__dict__['_kind'] = kind
-        self.__dict__['_value'] = value
+        self._parent = parent
+        self._key = key
+        self._kind = kind
+        self._value = value
 
     def __bool__(self):
-        return bool(self._value)
+        return self._value is not _Unknown
 
     def __len__(self):
+        if self._value is _Unknown:
+            return 0
         return len(self._value)
 
     def __contains__(self, key):
+        if self._value is _Unknown:
+            return False
         return key in self._value
 
     def __hash__(self):
+        if self._value is _Unknown:
+            return 0
         return hash(self._value)
 
     def __eq__(self, other):
+        if self._value is _Unknown:
+            return False
         if isinstance(other, FieldMessage):
             return self._value == other._value
         return self._value == other
 
+    def __bytes__(self):
+        if self._value is _Unknown:
+            return None
+        if isinstance(self._value, str):
+            return self._value.encode('utf-8')
+        return bytes(self._value)
+
     def __str__(self):
+        if self._value is _Unknown:
+            return None
+        if isinstance(self._value, bytes):
+            return self._value.decode('utf-8')
         return str(self._value)
 
     def __format__(self, spec=''):
+        if self._value is _Unknown:
+            return None
         return format(self._value, spec)
 
     def __int__(self):
+        if self._value is _Unknown:
+            return None
         return int(self._value)
 
     def __float__(self):
+        if self._value is _Unknown:
+            return None
         return float(self._value)
 
     def _fullName(self, key=None):
@@ -576,16 +646,16 @@ class ProtobufValue:
 
 class Value:
     def __init__(self, parent, key, value=_Unknown, readOnly=None):
-        self.__dict__['_parent'] = parent
-        self.__dict__['_key'] = key
-        self.__dict__['_dependencies'] = {}
-        self.__dict__['_unknowns'] = {}
-        self.__dict__['_cache'] = {}
-        self.__dict__['_readOnly'] = None
+        self._set_attribute('_parent', parent)
+        self._set_attribute('_key', key)
+        self._set_attribute('_dependencies', {})
+        self._set_attribute('_unknowns', {})
+        self._set_attribute('_cache', {})
+        self._set_attribute('_readOnly', None)
         if isinstance(value, (google.protobuf.struct_pb2.Value, google.protobuf.struct_pb2.Struct, google.protobuf.struct_pb2.ListValue)) or value is _Unknown:
-            self.__dict__['_value'] = value
+            self._set_attribute('_value', value)
         else:
-            self.__dict__['_value'] = google.protobuf.struct_pb2.Value()
+            self._set_attribute('_value', google.protobuf.struct_pb2.Value())
             if value is None:
                 self._value.null_value = 0
             elif isinstance(value, dict):
@@ -604,12 +674,16 @@ class Value:
                 self._value.string_value = value
             else:
                 raise ValueError(f"Unexpected Value type: {value.__class__}")
-        self.__dict__['_readOnly'] = readOnly
+        self._set_attribute('_readOnly', readOnly)
+
+    def _set_attribute(self, key, value):
+        self.__dict__[key] = value
 
     def __getattr__(self, key):
         return self[key]
 
     def __getitem__(self, key):
+        key = self._validate_key(key)
         if key in self._cache:
             return self._cache[key]
         if key in self._unknowns:
@@ -641,7 +715,7 @@ class Value:
                 case _:
                     raise ValueError(f"Invalid key \"{key}\" for kind: {self._kind}")
         else:
-            raise ValueError(f"Unexpected key type: {key.__class__}")
+            raise NotImplementedError()
         value = Value(self, key, value, self._readOnly)
         self._cache[key] = value
         return value
@@ -659,6 +733,10 @@ class Value:
                 return len(self._value.list_value.values) + len(self._unknowns)
             case 'ListValue':
                 return len(self._value.values) + len(self._unknowns)
+            case 'string_value':
+                return len(self._value.string_value)
+            case 'bool_value':
+                return 1 if self._value.bool_value else 0
         return 0
 
     def __contains__(self, item):
@@ -860,6 +938,7 @@ class Value:
     def __setitem__(self, key, value):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if isinstance(key, str):
             if self._ensure_map() == 'struct_value':
                 values = self._value.struct_value.fields
@@ -877,7 +956,7 @@ class Value:
             while key >= len(values):
                 values.add()
         else:
-            raise ValueError('Unexpected key type')
+            raise NotImplementedError()
         self._cache.pop(key, None)
         self._dependencies.pop(key, None)
         self._unknowns.pop(key, None)
@@ -887,6 +966,8 @@ class Value:
             values[key].null_value = 0
         elif isinstance(value, bool): # Must be before int check
             values[key].bool_value = value
+        elif isinstance(value, bytes):
+            values[key].string_value = value._value.decode('utf-8')
         elif isinstance(value, str):
             values[key].string_value = value
         elif isinstance(value, (int, float)):
@@ -995,6 +1076,7 @@ class Value:
         kind = self._kind
         if kind == 'Unknown':
             return
+        key = self._validate_key(key)
         if isinstance(key, str):
             match kind:
                 case 'struct_value':
@@ -1036,11 +1118,12 @@ class Value:
                     break
                 del values[ix]
         else:
-            raise ValueError('Unexpected key type')
+            raise NotImplementedError()
 
     def _create_child(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
+        key = self._validate_key(key)
         if isinstance(key, str):
             if self._ensure_map() == 'struct_value':
                 fields = self._value.struct_value.fields
@@ -1061,7 +1144,16 @@ class Value:
                 values.add()
             values[key].Clear()
             return values[key]
-        raise ValueError('Unexpected key type')
+        raise NotImplementedError()
+
+    def _validate_key(self, key):
+        if isinstance(key, FieldMessage):
+            key = key._value
+        elif isinstance(key, Value):
+            key = key._raw
+        if not isinstance(key, (str, int)):
+            raise TypeError(f"Unexpected key type: {key.__class__}")
+        return key
 
     def _ensure_map(self):
         kind = self._kind
@@ -1154,13 +1246,14 @@ class Value:
             for key, value in self:
                 if isinstance(value, Value) and len(value):
                     patch = patches[key]
-                    if isinstance(patch, Value) and patch._type == value._type and len(patch):
+                    print(patch.__class__, str(patch))
+                    if isinstance(patch, Value) and patch._kind == value._kind and len(patch):
                         value._patchUnknowns(patch)
         elif self._isList:
             for ix, value in enumerate(self):
                 if isinstance(value, Value) and len(value):
                     patch = patches[ix]
-                    if isinstance(patch, Value) and patch._type == value._type and len(patch):
+                    if isinstance(patch, Value) and patch._kind == value._kind and len(patch):
                         value._patchUnknowns(patch)
 
     def _renderUnknowns(self, trimFullName):

crossplane/pythonic/render.py

@@ -53,14 +53,6 @@ class Command(command.Command):
             metavar='PATH',
             help='A YAML file or directory of YAML files specifying the observed state of composed resources.'
         )
-        parser.add_argument(
-            '--extra-resources',
-            action='append',
-            type=pathlib.Path,
-            default=[],
-            metavar='PATH',
-            help='A YAML file or directory of YAML files specifying required resources (deprecated, use --required-resources).',
-        )
         parser.add_argument(
             '--required-resources', '-e',
             action='append',
@@ -70,18 +62,23 @@ class Command(command.Command):
             help='A YAML file or directory of YAML files specifying required resources to pass to the Function pipeline.',
         )
         parser.add_argument(
-            '--function-credentials',
+            '--secret-store', '-s',
             action='append',
             type=pathlib.Path,
             default=[],
             metavar='PATH',
-            help='A YAML file or directory of YAML files specifying credentials to use for Functions to render the XR.',
+            help='A YAML file or directory of YAML files specifying Secrets to use to resolve connections and credentials.',
         )
         parser.add_argument(
             '--include-full-xr', '-x',
             action='store_true',
             help="Include a direct copy of the input XR's spedc and metadata fields in the rendered output.",
         )
+        parser.add_argument(
+            '--include-connection-xr',
+            action='store_true',
+            help="Include the Composite connection values in the rendered output as a resource of kind: Connection.",
+        )
         parser.add_argument(
             '--include-function-results', '-r',
             action='store_true',
@@ -158,29 +155,33 @@ class Command(command.Command):
                 sys.exit(1)
             request.context[key_value[0]] = protobuf.Yaml(key_value[1])
 
-        # Establish the request observed composite and specifed observed resources.
-        request.observed.composite.resource = composite
+        # Collect specified required/extra resources. Sort for stable order when processed.
+        requireds = sorted(
+            self.collect_resources(self.args.required_resources),
+            key=lambda required: str(required.metadata.name),
+        )
+
+        # Collect specified connection and credential secrets.
+        secrets = []
+        for secret in self.collect_resources(self.args.secret_store):
+            if secret.apiVersion == 'v1' and secret.kind == 'Secret':
+                secrets.append(secret)
+
+        # Establish the request observed composite.
+        self.setup_resource(composite, secrets, request.observed.composite)
+
+        # Establish the configured observed resources.
         for resource in self.collect_resources(self.args.observed_resources):
             name = resource.metadata.annotations['crossplane.io/composition-resource-name']
             if name:
-                request.observed.resources[str(name)].resource = resource
-
-        # Collect specified required/extra resources.
-        requireds = [resource for resource in self.collect_resources(self.args.required_resources)]
-        requireds += [resource for resource in self.collect_resources(self.args.extra_resources)]
-
-        # Collect specified credential secrets.
-        credentials = []
-        for credential in self.collect_resources(self.args.function_credentials):
-            if credential.apiVersion == 'v1' and credential.kind == 'Secret':
-                credentials.append(credential)
+                self.setup_resource(resource, secrets, request.observed.resources[name])
 
         # These will hold the response conditions and results.
         conditions = protobuf.List()
         results = protobuf.List()
 
         # Create a function-pythonic function runner used to run pipeline steps.
-        runner = function.FunctionRunner(self.args.debug, self.args.render_unknowns)
+        runner = function.FunctionRunner(self.args.debug, self.args.render_unknowns, self.args.crossplane_v1)
         fatal = False
 
         # Process the composition pipeline steps.
@@ -194,18 +195,21 @@ class Command(command.Command):
 
             # Supply step requested credentials.
             request.credentials()
-            for fn_credential in step.credentials:
-                if fn_credential.source == 'Secret' and fn_credential.secretRef:
-                    for credential in credentials:
-                        if credential.metadata.namespace == fn_credential.secretRef.namespace and credential.metadata.name == fn_credential.secretRef.name:
-                            data = request.credentials[str(fn_credential.name)].credential_data.data
-                            data()
-                            for key, value in credential.data:
-                                data[key] = protobuf.B64Decode(value)
-                            break
-                    else:
-                        print(f"Step \"{step.step}\" secret not found: {fn_credential.secretRef.namespace} {fn_credential.secretRef.name}", file=sys.stderr)
-                        sys.exit(1)
+            for credential in step.credentials:
+                if credential.source == 'Secret' and credential.secretRef:
+                    namespace = credential.secretRef.namespace
+                    name = credential.secretRef.name
+                    if namespace and name:
+                        for secret in secrets:
+                            if secret.metadata.namespace == namespace and secret.metadata.name == name:
+                                data = request.credentials[credential.name].credential_data.data
+                                data()
+                                for key, value in secret.data:
+                                    data[key] = protobuf.B64Decode(value)
+                                break
+                        else:
+                            print(f"Step \"{step.step}\" secret not found: {namespace}/{name}", file=sys.stderr)
+                            sys.exit(1)
 
             # Track what extra/required resources have been processed.
             requirements = protobuf.Message(None, 'requirements', fnv1.Requirements.DESCRIPTOR, fnv1.Requirements())
@@ -213,14 +217,14 @@ class Command(command.Command):
                 # Fetch the step bootstrap resources specified.
                 request.required_resources()
                 for requirement in step.requirements:
-                    self.fetch_requireds(requireds, requirement.requirementName, requirement, request.required_resources)
+                    self.fetch_requireds(requireds, secrets, requirement.requirementName, requirement, request.required_resources)
                 # Fetch the required resources requested.
                 for name, selector in requirements.resources:
-                    self.fetch_requireds(requireds, name, selector, request.required_resources)
+                    self.fetch_requireds(requireds, secrets, name, selector, request.required_resources)
                 # Fetch the now deprecated extra resources requested.
                 request.extra_resources()
                 for name, selector in requirements.extra_resources:
-                    self.fetch_requireds(requireds, name, selector, request.extra_resources)
+                    self.fetch_requireds(requireds, secrets, name, selector, request.extra_resources)
                 # Run the step using the function-pythonic function runner.
                 response = protobuf.Message(
                     None,
@@ -330,15 +334,29 @@ class Command(command.Command):
         # Print the composite.
         print('---')
         print(str(composite), end='')
+
+        # Print Composite connection if requested.
+        if self.args.include_connection_xr:
+            connection = protobuf.Map(
+                apiVersion = 'render.crossplane.io/v1beta1',
+                kind = 'Connection',
+            )
+            for key, value in request.desired.composite.connection_details:
+                connection.values[key] = value
+            print('---')
+            print(str(connection), end='')
+
         # Print the composed resources.
         for resource in sorted(resources, key=lambda resource: str(resource.metadata.annotations['crossplane.io/composition-resource-name'])):
             print('---')
             print(str(resource), end='')
+
         # Print the results (AKA events) if requested.
         if self.args.include_function_results:
             for result in results:
                 print('---')
                 print(str(result), end='')
+
         # Print the final context if requested.
         if self.args.include_context:
             print('---')
@@ -346,7 +364,7 @@ class Command(command.Command):
                 str(protobuf.Map(
                     apiVersion = 'render.crossplane.io/v1beta1',
                     kind = 'Context',
-                    fields = request.context,
+                    values = request.context,
                 )),
                 end='',
             )
@@ -382,7 +400,19 @@ class Command(command.Command):
             for document in yaml.safe_load_all(file.read_text()):
                 yield protobuf.Value(None, None, document)
 
-    def fetch_requireds(self, requireds, name, selector, resources):
+    def setup_resource(self, source, secrets, resource):
+        resource.resource = source
+        namespace = source.spec.writeConnectionSecretToRef.namespace or source.metadata.namespace
+        name = source.spec.writeConnectionSecretToRef.name
+        if namespace and name:
+            for secret in secrets:
+                if secret.metadata.namespace == namespace and secret.metadata.name == name:
+                    resource.connection_details()
+                    for key, value in secret.data:
+                        resource.connection_details[key] = protobuf.B64Decode(value)
+                    break
+
+    def fetch_requireds(self, requireds, secrets, name, selector, resources):
         if not name:
             return
         name = str(name)
@@ -391,13 +421,13 @@ class Command(command.Command):
         for required in requireds:
             if selector.api_version == required.apiVersion and selector.kind == required.kind:
                 if selector.match_name == required.metadata.name:
-                    items[protobuf.append].resource = required
+                    self.setup_resource(required, secrets, items[protobuf.append])
                 elif selector.match_labels.labels:
                     for key, value in selector.match_labels.labels:
                         if value != required.metadata.labels[key]:
                             break
                     else:
-                        items[protobuf.append].resource = required
+                        self.setup_resource(required, secrets, items[protobuf.append])
 
     def copy_resource(self, source, destination):
         destination.resource = source.resource

crossplane/pythonic/version.py

@@ -1,7 +1,7 @@
 
 from . import (
-    command,
     __about__,
+    command,
 )