Implement support for connection information during function-pythonic render

Signed-off-by: Patrick J. McNerthney <[email protected]>

Author: iciclespider

README.md

@@ -204,8 +204,9 @@ 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.results | Results | Returned results applied to the Composite and optionally on the Claim |
-| self.connection | Connection | The composite desired and observed connection detials, read from observed if not in desired |
+| self.connection | Map | The composite desired connection detials |
 | self.ready | Boolean | The composite desired ready state |
+| self.observed.connection | Map | The composite observed connection detials |
 
 The BaseComposite also provides access to the following Crossplane Function level features:
 
@@ -246,7 +247,7 @@ Resource class:
 | Resource.data | Map | The resource data |
 | Resource.status | Map | The resource status |
 | Resource.conditions | Conditions | The resource conditions |
-| Resource.connection | Connection | The resource connection details |
+| Resource.connection | Map | The resource observed connection details |
 | Resource.ready | Boolean | The resource ready state |
 | Resource.unknownsFatal | Boolean | Terminate the composition if this resource has been created and is assigned unknown values, default is Composite.unknownsFatal |
 | Resource.usages | Boolean | Generate Crossplane Usages for this resource, default is Composite.autoReady |
@@ -286,6 +287,7 @@ Each resource in the list is the following RequiredResource class:
 | RequiredResource.data | Map | The required resource data |
 | RequiredResource.status | Map | The required resource status |
 | RequiredResource.conditions | Map | The required resource conditions |
+| RequiredResource.connection | Map | The required resource connection details |
 
 ### Conditions
 
@@ -348,11 +350,11 @@ $ pip install crossplane-function-pythonic
 Then to render function-pythonic Compositions, use the `function-pythonic render ...`
 command.
 ```shell
-$ function-pythonic render --help
+$ function-pythonic render -h
 usage: Crossplane Function Pythonic render [-h] [--debug] [--log-name-width WIDTH] [--python-path DIRECTORY] [--render-unknowns]
                                            [--allow-oversize-protos] [--context-files KEY=PATH] [--context-values KEY=VALUE]
-                                           [--observed-resources PATH] [--extra-resources PATH] [--required-resources PATH]
-                                           [--function-credentials PATH] [--include-full-xr] [--include-function-results] [--include-context]
+                                           [--observed-resources PATH] [--required-resources PATH] [--secret-store PATH] [--include-full-xr]
+                                           [--include-connection-xr] [--include-function-results] [--include-context]
                                            PATH [PATH/CLASS]
 
 positional arguments:
@@ -376,14 +378,14 @@ options:
                         Context key-value pairs to pass to the Function pipeline. Values must be YAML/JSON. Keys take precedence over --context-files.
   --observed-resources, -o PATH
                         A YAML file or directory of YAML files specifying the observed state of composed resources.
-  --extra-resources PATH
-                        A YAML file or directory of YAML files specifying required resources (deprecated, use --required-resources).
   --required-resources, -e PATH
                         A YAML file or directory of YAML files specifying required resources to pass to the Function pipeline.
-  --function-credentials PATH
-                        A YAML file or directory of YAML files specifying credentials to use for Functions to render the XR.
+  --secret-store, -s PATH
+                        A YAML file or directory of YAML files specifying Secrets to use to resolve connections and credentials.
   --include-full-xr, -x
                         Include a direct copy of the input XR's spedc and metadata fields in the rendered output.
+  --include-connection-xr
+                        Include the Composite connection values in the rendered output as a resource of kind: Connection.
   --include-function-results, -r
                         Include informational and warning messages from Functions in the rendered output as resources of kind: Result..
   --include-context, -c

crossplane/pythonic/composite.py

@@ -40,6 +40,7 @@ def __init__(self, request, single_use, logger):
         observed = self.request.observed.composite
         desired = self.response.desired.composite
         self.observed = observed.resource
+        self.observed._set_attribute('connection', self.request.observed.composite.connection_details)
         self.desired = desired.resource
         self.apiVersion = self.observed.apiVersion
         self.kind = self.observed.kind
@@ -434,6 +435,7 @@ def __init__(self, name, ix, resource):
         self.data = self.observed.data
         self.status = self.observed.status
         self.conditions = Conditions(resource)
+        self.connection = self.observed.connection_details
 
     def __bool__(self):
         return bool(self.observed)

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 @@ def _fullName(self, key=None):
     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 @@ def __setattr__(self, key, value):
     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 @@ def __delattr__(self, key):
     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 @@ def _fullName(self, key=None):
     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 @@ def __setattr__(self, key, message):
     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 @@ def __delattr__(self, key):
     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 @@ def __init__(self, parent, key, field, messages=_Unknown, readOnly=False):
         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 @@ def _fullName(self, key=None):
     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 @@ def __call__(self, *args):
     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 @@ def __setitem__(self, key, message):
     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,13 +550,22 @@ def append(self, message=_Unknown):
             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)
@@ -539,7 +584,14 @@ def __eq__(self, other):
             return self._value == other._value
         return self._value == other
 
+    def __bytes__(self):
+        if isinstance(self._value, str):
+            return self._value.encode('utf-8')
+        return bytes(self._value)
+
     def __str__(self):
+        if isinstance(self._value, bytes):
+            return self._value.decode('utf-8')
         return str(self._value)
 
     def __format__(self, spec=''):
@@ -576,16 +628,16 @@ def _protobuf_value(self):
 
 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 +656,16 @@ def __init__(self, parent, key, value=_Unknown, readOnly=None):
                 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 +697,7 @@ def __getitem__(self, key):
                 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
@@ -860,6 +916,7 @@ def __setattr__(self, key, 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 +934,7 @@ def __setitem__(self, key, 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 +944,8 @@ def __setitem__(self, key, 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 +1054,7 @@ def __delitem__(self, key):
         kind = self._kind
         if kind == 'Unknown':
             return
+        key = self._validate_key(key)
         if isinstance(key, str):
             match kind:
                 case 'struct_value':
@@ -1036,11 +1096,12 @@ def __delitem__(self, key):
                     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 +1122,16 @@ def _create_child(self, key):
                 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