crossplane-function-pythonic 0.0.10__py3-none-any.whl → 0.1.0__py3-none-any.whl

crossplane/pythonic/__init__.py

@@ -1,10 +1,7 @@
 
-import base64
 
 from .composite import BaseComposite
-from .protobuf import append, Map, List, Unknown, Yaml, Json
-B64Encode = lambda s: base64.b64encode(s.encode('utf-8')).decode('utf-8')
-B64Decode = lambda s: base64.b64decode(s.encode('utf-8')).decode('utf-8')
+from .protobuf import append, Map, List, Unknown, Yaml, Json, B64Encode, B64Decode
 
 __all__ = [
     'BaseComposite',

crossplane/pythonic/composite.py

@@ -1,5 +1,6 @@
 
 import datetime
+from google.protobuf.duration_pb2 import Duration
 from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 
 from . import protobuf
@@ -9,8 +10,18 @@ _notset = object()
 
 
 class BaseComposite:
-    def __init__(self, request, response, logger):
+    def __init__(self, request, logger):
         self.request = protobuf.Message(None, 'request', request.DESCRIPTOR, request, 'Function Request')
+        response = fnv1.RunFunctionResponse(
+            meta=fnv1.ResponseMeta(
+                tag=request.meta.tag,
+                ttl=Duration(
+                    seconds=60,
+                ),
+            ),
+            desired=request.desired,
+            context=request.context,
+        )
         self.response = protobuf.Message(None, 'response', response.DESCRIPTOR, response)
         self.logger = logger
         self.credentials = Credentials(self.request)
@@ -20,6 +31,7 @@ class BaseComposite:
         self.resources = Resources(self)
         self.unknownsFatal = True
         self.autoReady = True
+        self.usages = False
 
         observed = self.request.observed.composite
         desired = self.response.desired.composite
@@ -36,11 +48,23 @@ class BaseComposite:
 
     @property
     def ttl(self):
-        return self.response.meta.ttl.seconds
+        if self.response.meta.ttl.nanos:
+            return float(self.response.meta.ttl.seconds) + (float(self.response.meta.ttl.nanos) / 1000000000.0)
+        return int(self.response.meta.ttl.seconds)
 
     @ttl.setter
     def ttl(self, ttl):
-        self.response.meta.ttl.seconds = ttl    
+        if isinstance(ttl, int):
+            self.response.meta.ttl.seconds = ttl
+            self.response.meta.ttl.nanos = 0
+        elif isinstance(ttl, float):
+            self.response.meta.ttl.seconds = int(ttl)
+            if ttl.is_integer():
+                self.response.meta.ttl.nanos = 0
+            else:
+                self.response.meta.ttl.nanos = int((ttl - int(self.response.meta.ttl.seconds)) * 1000000000)
+        else:
+            raise ValueError('ttl must be an int or float')
 
     @property
     def ready(self):
@@ -55,7 +79,7 @@ class BaseComposite:
     def ready(self, ready):
         if ready:
             ready = fnv1.Ready.READY_TRUE
-        elif ready == None or (isinstance(ready, protobuf.Values) and ready._isUnknown):
+        elif ready == None or (isinstance(ready, protobuf.Value) and ready._isUnknown):
             ready = fnv1.Ready.READY_UNSPECIFIED
         else:
             ready = fnv1.Ready.READY_FALSE
@@ -73,22 +97,46 @@ class Credentials:
         return self[key]
 
     def __getitem__(self, key):
-        return self._request.credentials[key].credentials_data.data
+        return Credential(self._request.credentials[key])
 
     def __bool__(self):
-        return bool(_request.credentials)
+        return bool(self._request.credentials)
 
     def __len__(self):
         return len(self._request.credentials)
 
     def __contains__(self, key):
-        return key in _request.credentials
+        return key in self._request.credentials
 
     def __iter__(self):
         for key, resource in self._request.credentials:
             yield key, self[key]
 
 
+class Credential:
+    def __init__(self, credential):
+        self.__dict__['_credential'] = credential
+
+    def __getattr__(self, key):
+        return self[key]
+
+    def __getitem__(self, key):
+        return self._credential.credential_data.data[key]
+
+    def __bool__(self):
+        return bool(self._credential.credential_data.data)
+
+    def __len__(self):
+        return len(self._credential.credential_data.data)
+
+    def __contains__(self, key):
+        return key in self._credential.credential_data.data
+
+    def __iter__(self):
+        for key, resource in self._credential.credential_data.data:
+            yield key, self[key]
+
+
 class Resources:
     def __init__(self, composite):
         self.__dict__['_composite'] = composite
@@ -137,6 +185,7 @@ class Resource:
         self.connection = Connection(observed)
         self.unknownsFatal = None
         self.autoReady = None
+        self.usages = None
 
     def __call__(self, apiVersion=_notset, kind=_notset, namespace=_notset, name=_notset):
         self.desired()
@@ -152,7 +201,7 @@ class Resource:
 
     @property
     def apiVersion(self):
-        return self.observed.apiVersion
+        return self.desired.apiVersion
 
     @apiVersion.setter
     def apiVersion(self, apiVersion):
@@ -160,7 +209,7 @@ class Resource:
 
     @property
     def kind(self):
-        return self.observed.kind
+        return self.desired.kind
 
     @kind.setter
     def kind(self, kind):
@@ -218,7 +267,7 @@ class Resource:
     def ready(self, ready):
         if ready:
             ready = fnv1.Ready.READY_TRUE
-        elif ready == None or (isinstance(ready, protobuf.Values) and ready._isUnknown):
+        elif ready == None or (isinstance(ready, protobuf.Value) and ready._isUnknown):
             ready = fnv1.Ready.READY_UNSPECIFIED
         else:
             ready = fnv1.Ready.READY_FALSE
@@ -329,8 +378,8 @@ class RequiredResources:
                 elif isinstance(entry, (list, tuple)):
                     self._selector.match_labels.labels[entry[0]] = entry[1]
 
-    def __getitem__(self, key):
-        return RequiredResource(self.name, self._resources.items[key])
+    def __getitem__(self, ix):
+        return RequiredResource(self.name, ix, self._resources.items[ix])
 
     def __bool__(self):
         return bool(self._resources.items)
@@ -344,8 +393,9 @@ class RequiredResources:
 
 
 class RequiredResource:
-    def __init__(self, name, resource):
+    def __init__(self, name, ix, resource):
         self.name = name
+        self.ix = ix
         self.observed = resource.resource
         self.apiVersion = self.observed.apiVersion
         self.kind = self.observed.kind
@@ -440,7 +490,7 @@ class Condition(protobuf.ProtobufValue):
             condition.status = fnv1.Status.STATUS_CONDITION_TRUE
         elif status == None:
             condition.status = fnv1.Status.STATUS_CONDITION_UNKNOWN
-        elif isinstance(status, protobuf.Values) and status._isUnknown:
+        elif isinstance(status, protobuf.Value) and status._isUnknown:
             condition.status = fnv1.Status.STATUS_CONDITION_UNSPECIFIED
         else:
             condition.status = fnv1.Status.STATUS_CONDITION_FALSE
@@ -474,7 +524,7 @@ class Condition(protobuf.ProtobufValue):
             if observed.type == self.type:
                 time = observed.lastTransitionTime
                 if time:
-                    return datetime.datetime.fromisoformat(time)
+                    return datetime.datetime.fromisoformat(str(time))
         return None
 
     @property
@@ -487,7 +537,7 @@ class Condition(protobuf.ProtobufValue):
         condition = self._find_condition(True)
         if claim:
             condition.target = fnv1.Target.TARGET_COMPOSITE_AND_CLAIM
-        elif claim == None or (isinstance(claim, protobuf.Values) and claim._isUnknown):
+        elif claim == None or (isinstance(claim, protobuf.Value) and claim._isUnknown):
             condition.target = fnv1.Target.TARGET_UNSPECIFIED
         else:
             condition.target = fnv1.Target.TARGET_COMPOSITE
@@ -587,7 +637,7 @@ class Events:
     def __getitem__(self, key):
         if key >= len(self._results):
             return Event()
-        return Event(self._results[ix])
+        return Event(self._results[key])
 
     def __iter__(self):
         for ix in range(len(self._results)):
@@ -664,7 +714,7 @@ class Event:
         if bool(self):
             if claim:
                 self._result.target = fnv1.Target.TARGET_COMPOSITE_AND_CLAIM
-            elif claim == None or (isinstance(claim, protobuf.Values) and claim._isUnknown):
+            elif claim == None or (isinstance(claim, protobuf.Value) and claim._isUnknown):
                 self._result.target = fnv1.Target.TARGET_UNSPECIFIED
             else:
                 self._result.target = fnv1.Target.TARGET_COMPOSITE

crossplane/pythonic/function.py

@@ -1,38 +1,26 @@
 """A Crossplane composition function."""
 
 import asyncio
-import base64
-import builtins
 import importlib
 import inspect
 import logging
 import sys
 
 import grpc
-import crossplane.function.response
 from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 from crossplane.function.proto.v1 import run_function_pb2_grpc as grpcv1
 from .. import pythonic
 
-builtins.BaseComposite = pythonic.BaseComposite
-builtins.append = pythonic.append
-builtins.Map = pythonic.Map
-builtins.List = pythonic.List
-builtins.Unknown = pythonic.Unknown
-builtins.Yaml = pythonic.Yaml
-builtins.Json = pythonic.Json
-builtins.B64Encode = pythonic.B64Encode
-builtins.B64Decode = pythonic.B64Decode
-
 logger = logging.getLogger(__name__)
 
 
 class FunctionRunner(grpcv1.FunctionRunnerService):
     """A FunctionRunner handles gRPC RunFunctionRequests."""
 
-    def __init__(self, debug=False):
+    def __init__(self, debug=False, renderUnknowns=False):
         """Create a new FunctionRunner."""
         self.debug = debug
+        self.renderUnknowns = renderUnknowns
         self.clazzes = {}
 
     def invalidate_module(self, module):
@@ -46,9 +34,8 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
     ) -> fnv1.RunFunctionResponse:
         try:
             return await self.run_function(request)
-        except:
-            logger.exception('Exception thrown in run fuction')
-            raise
+        except Exception as e:
+            return self.fatal(request, logger, 'RunFunction', e)
 
     async def run_function(self, request):
         composite = request.observed.composite.resource
@@ -56,27 +43,22 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         name.append(composite['kind'])
         name.append(composite['metadata']['name'])
         logger = logging.getLogger('.'.join(name))
-        if 'iteration' in request.context:
-            request.context['iteration'] = request.context['iteration'] + 1
-        else:
-            request.context['iteration'] = 1
-        logger.debug(f"Starting compose, {ordinal(request.context['iteration'])} pass")
-
-        response = crossplane.function.response.to(request)
 
         if composite['apiVersion'] == 'pythonic.fortra.com/v1alpha1' and composite['kind'] == 'Composite':
-            if 'composite' not in composite['spec']:
-                logger.error('Missing spec "composite"')
-                crossplane.function.response.fatal(response, 'Missing spec "composite"')
-                return response
+            if 'spec' not in composite or 'composite' not in composite['spec']:
+                return self.fatal(request, logger, 'Missing spec "composite"')
             composite = composite['spec']['composite']
         else:
             if 'composite' not in request.input:
-                logger.error('Missing input "composite"')
-                crossplane.function.response.fatal(response, 'Missing input "composite"')
-                return response
+                return self.fatal(request, logger, 'Missing input "composite"')
             composite = request.input['composite']
 
+        # Ideally this is something the Function API provides
+        if 'step' in request.input:
+            step = request.input['step']
+        else:
+            step = str(hash(composite))
+
         clazz = self.clazzes.get(composite)
         if not clazz:
             if '\n' in composite:
@@ -84,82 +66,174 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                 try:
                     exec(composite, module.__dict__)
                 except Exception as e:
-                    logger.exception('Exec exception')
-                    crossplane.function.response.fatal(response, f"Exec exception: {e}")
-                    return response
+                    return self.fatal(request, logger, 'Exec', e)
                 for field in dir(module):
                     value = getattr(module, field)
-                    if inspect.isclass(value) and issubclass(value, BaseComposite) and value != BaseComposite:
+                    if inspect.isclass(value) and issubclass(value, pythonic.BaseComposite) and value != pythonic.BaseComposite:
                         if clazz:
-                            logger.error('Composite script has multiple BaseComposite classes')
-                            crossplane.function.response.fatal(response, 'Composite script has multiple BaseComposite classes')
-                            return response
+                            return self.fatal(request, logger, 'Composite script has multiple BaseComposite classes')
                         clazz = value
                 if not clazz:
-                    logger.error('Composite script does not have have a BaseComposite class')
-                    crossplane.function.response.fatal(response, 'Composite script does have have a BaseComposite class')
-                    return response
+                    return self.fatal(request, logger, 'Composite script does not have a BaseComposite class')
             else:
                 composite = composite.rsplit('.', 1)
                 if len(composite) == 1:
-                    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
+                    return self.fatal(request, logger, f"Composite class name does not include module: {composite[0]}")
                 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}")
-                    return response
+                    return self.fatal(request, logger, 'Import module', e)
                 clazz = getattr(module, composite[1], None)
                 if not clazz:
-                    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
+                    return self.fatal(request, logger, f"{composite[0]} does not define: {composite[1]}")
                 composite = '.'.join(composite)
                 if not inspect.isclass(clazz):
-                    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):
-                    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
+                    return self.fatal(request, logger, f"{composite} is not a class")
+                if not issubclass(clazz, pythonic.BaseComposite):
+                    return self.fatal(request, logger, f"{composite} is not a subclass of BaseComposite")
             self.clazzes[composite] = clazz
 
         try:
-            composite = clazz(request, response, logger)
+            composite = clazz(request, logger)
         except Exception as e:
-            logger.exception('Instatiate exception')
-            crossplane.function.response.fatal(response, f"Instatiate exception: {e}")
-            return response
+            return self.fatal(request, logger, 'Instantiate', e)
+
+        step = composite.context._pythonic[step]
+        iteration = int(step.iteration) + 1
+        step.iteration = iteration
+        composite.context.iteration = iteration
+        logger.debug(f"Starting compose, {ordinal(len(composite.context._pythonic))} step, {ordinal(iteration)} pass")
 
         try:
             result = composite.compose()
             if asyncio.iscoroutine(result):
                 await result
         except Exception as e:
-            logger.exception('Compose exception')
-            crossplane.function.response.fatal(response, f"Compose exception: {e}")
-            return response
+            return self.fatal(request, logger, 'Compose', e)
+
+        if requireds := self.get_requireds(step, composite):
+            logger.info(f"Requireds requested: {','.join(requireds)}")
+        else:
+            self.process_usages(composite)
+            self.process_unknowns(composite)
+            self.process_auto_readies(composite)
+            logger.info('Completed compose')
 
-        requested = []
+        return composite.response._message
+
+    def fatal(self, request, logger, message, exception=None):
+        if exception:
+            message += ' exceptiion'
+            logger.exception(message)
+            m = str(exception)
+            if not m:
+                m = exception.__class__.__name__
+            message += ': ' + m
+        else:
+            logger.error(message)
+        return fnv1.RunFunctionResponse(
+            meta=fnv1.ResponseMeta(
+                tag=request.meta.tag,
+            ),
+            results=[
+                fnv1.Result(
+                    severity=fnv1.SEVERITY_FATAL,
+                    message=message,
+                )
+            ]
+        )
+
+    def get_requireds(self, step, composite):
+        requireds = []
         for name, required in composite.requireds:
             if required.apiVersion and required.kind:
-                r = Map(apiVersion=required.apiVersion, kind=required.kind)
+                r = pythonic.Map(apiVersion=required.apiVersion, kind=required.kind)
                 if required.namespace:
                     r.namespace = required.namespace
                 if required.matchName:
                     r.matchName = required.matchName
                 for key, value in required.matchLabels:
                     r.matchLabels[key] = value
-                if r != composite.context._requireds[name]:
-                    composite.context._requireds[name] = r
-                    requested.append(name)
-        if requested:
-            logger.info(f"Requireds requested: {','.join(requested)}")
-            return response
+                if r != step.requireds[name]:
+                    step.requireds[name] = r
+                    requireds.append(name)
+        return requireds
+
+    def process_usages(self, composite):
+        for _, resource in sorted(entry for entry in composite.resources):
+            dependencies = resource.desired._getDependencies
+            if dependencies:
+                if self.debug:
+                    for destination, source in sorted(dependencies.items()):
+                        destination = self.trimFullName(destination)
+                        source = self.trimFullName(source)
+                        composite.logger.debug(f"Dependency: {destination} = {source}")
+                if resource.usages or (resource.usages is None and composite.usages):
+                    resources = {}
+                    requireds = {}
+                    for destination, source in sorted(dependencies.items()):
+                        name = source.split('.')
+                        if (len(name) > 5 and
+                            name[0] == 'request' and
+                            name[1] == 'observed' and
+                            name[2] == 'resources' and
+                            name[4] == 'resource'
+                        ):
+                            if name[3] not in resources:
+                                resources[name[3]] = []
+                            resources[name[3]].append(f"{'.'.join(destination.split('.')[5:])} = {'.'.join(name[5:])}")
+                        elif (len(name) > 5 and
+                            name[0] == 'request' and
+                            name[1] == 'extra_resources' and
+                            name[3].startswith('items[') and name[3][-1] == ']' and
+                            name[4] == 'resource'
+                        ):
+                            key = (name[2], int(name[3][6:-1]))
+                            if key not in requireds:
+                                requireds[key] = []
+                            requireds[key].append(f"{'.'.join(destination.split('.')[5:])} = {'.'.join(name[5:])}")
+                    for name, dependencies in resources.items():
+                        source = composite.resources[name]
+                        name = [resource.name, str(source.kind)]
+                        if source.metadata.namespace:
+                            name.append(str(source.metadata.namespace))
+                        name.append(str(source.observed.metadata.name))
+                        usage = composite.resources['_'.join(name)]('apiextensions.crossplane.io/v1beta1', 'Usage')
+                        #usage = composite.resources['_'.join(name)]('protection.crossplane.io/v1beta1', 'Usage')
+                        if resource.metadata.namespace:
+                            usage.metadata.namespace = resource.metadata.namespace
+                        usage.spec.reason = '\n'.join(dependencies)
+                        usage.spec.replayDeletion = True
+                        usage.spec.by.apiVersion = resource.apiVersion
+                        usage.spec.by.kind = resource.kind
+                        usage.spec.by.resourceRef.name = resource.observed.metadata.name
+                        usage.spec.of.apiVersion = source.apiVersion
+                        usage.spec.of.kind = source.kind
+                        if source.metadata.namespace:
+                            usage.spec.of.resourceRef.namespace = source.metadata.namespace
+                        usage.spec.of.resourceRef.name = source.observed.metadata.name
+                    for key, dependencies in requireds.items():
+                        source = composite.requireds[key[0]][key[1]]
+                        name = [resource.name, str(source.kind)]
+                        if source.metadata.namespace:
+                            name.append(str(source.metadata.namespace))
+                        name.append(str(source.metadata.name))
+                        usage = composite.resources['_'.join(name)]('apiextensions.crossplane.io/v1beta1', 'Usage')
+                        #usage = composite.resources['_'.join(name)]('protection.crossplane.io/v1beta1', 'Usage')
+                        if resource.metadata.namespace:
+                            usage.metadata.namespace = resource.metadata.namespace
+                        usage.spec.reason = '\n'.join(dependencies)
+                        usage.spec.replayDeletion = True
+                        usage.spec.by.apiVersion = resource.apiVersion
+                        usage.spec.by.kind = resource.kind
+                        usage.spec.by.resourceRef.name = resource.observed.metadata.name
+                        usage.spec.of.apiVersion = source.apiVersion
+                        usage.spec.of.kind = source.kind
+                        if source.metadata.namespace:
+                            usage.spec.of.resourceRef.namespace = source.metadata.namespace
+                        usage.spec.of.resourceRef.name = source.observed.metadata.name
 
+    def process_unknowns(self, composite):
         unknownResources = []
         warningResources = []
         fatalResources = []
@@ -180,30 +254,32 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                         destination = self.trimFullName(destination)
                         source = self.trimFullName(source)
                         if fatal:
-                            logger.error(f'Observed unknown: {destination} = {source}')
+                            composite.logger.error(f'Observed unknown: {destination} = {source}')
                         elif warning:
-                            logger.warning(f'Observed unknown: {destination} = {source}')
+                            composite.logger.warning(f'Observed unknown: {destination} = {source}')
                         else:
-                            logger.debug(f'Desired unknown: {destination} = {source}')
+                            composite.logger.debug(f'Desired unknown: {destination} = {source}')
                 if resource.observed:
                     resource.desired._patchUnknowns(resource.observed)
+                elif self.renderUnknowns:
+                    resource.desired._renderUnknowns(self.trimFullName)
                 else:
                     del composite.resources[name]
 
         if fatalResources:
-            level = logger.error
+            level = composite.logger.error
             reason = 'FatalUnknowns'
             message = f"Observed resources with unknowns: {','.join(fatalResources)}"
             status = False
             event = composite.events.fatal
         elif warningResources:
-            level = logger.warning
+            level = composite.logger.warning
             reason = 'ObservedUnknowns'
             message = f"Observed resources with unknowns: {','.join(warningResources)}"
             status = False
             event = composite.events.warning
         elif unknownResources:
-            level = logger.info
+            level = composite.logger.info
             reason = 'DesiredUnknowns'
             message = f"Desired resources with unknowns: {','.join(unknownResources)}"
             status = False
@@ -220,26 +296,30 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         if event:
             event(reason, message)
 
+    def process_auto_readies(self, composite):
         for name, resource in composite.resources:
             if resource.autoReady or (resource.autoReady is None and composite.autoReady):
                 if resource.ready is None:
                     if resource.conditions.Ready.status:
                         resource.ready = True
 
-        logger.info('Completed compose')
-        return response
-
     def trimFullName(self, name):
         name = name.split('.')
         for values in (
+                ('request', 'observed', 'composite', 'resource'),
                 ('request', 'observed', 'resources', None, 'resource'),
-                ('request', 'extra_resources', None, 'items', 'resource'),
+                ('request', 'extra_resources', None, 'items', None, 'resource'),
                 ('response', 'desired', 'resources', None, 'resource'),
         ):
-            if len(values) <= len(name):
-                for ix, value in enumerate(values):
-                    if value and value != name[ix] and not name[ix].startswith(f"{value}["):
-                       break
+            if len(values) < len(name):
+                ix = 0
+                for iv, value in enumerate(values):
+                    if value:
+                        if value != name[ix]:
+                            if not name[ix].startswith(f"{values[iv]}[") or iv+1 >= len(values) or values[iv+1]:
+                                break
+                            continue
+                    ix += 1
                 else:
                     ix = 0
                     for value in values:
@@ -251,7 +331,6 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                                 del name[ix]
                             else:
                                 name[ix] = name[ix][len(value):]
-                                ix += 1
                         else:
                             ix += 1
                     break
@@ -268,4 +347,13 @@ def ordinal(ix):
 
 
 class Module:
-    pass
+    def __init__(self):
+        self.BaseComposite = pythonic.BaseComposite
+        self.append = pythonic.append
+        self.Map = pythonic.Map
+        self.List = pythonic.List
+        self.Unknown = pythonic.Unknown
+        self.Yaml = pythonic.Yaml
+        self.Json = pythonic.Json
+        self.B64Encode = pythonic.B64Encode
+        self.B64Decode = pythonic.B64Decode

crossplane/pythonic/main.py

@@ -92,6 +92,11 @@ class Main:
             action='store_true',
             help='Allow oversized protobuf messages'
         )
+        parser.add_argument(
+            '--render-unknowns',
+            action='store_true',
+            help='Render resources with unknowns, useful during local develomment'
+        )
         args = parser.parse_args()
         if not args.tls_certs_dir and not args.insecure:
             print('Either --tls-certs-dir or --insecure must be specified', file=sys.stderr)
@@ -117,7 +122,7 @@ class Main:
                 api_implementation._c_module.SetAllowOversizeProtos(True)
 
         grpc.aio.init_grpc_aio()
-        grpc_runner = function.FunctionRunner(args.debug)
+        grpc_runner = function.FunctionRunner(args.debug, args.render_unknowns)
         grpc_server = grpc.aio.server()
         grpcv1.add_FunctionRunnerServiceServicer_to_server(grpc_runner, grpc_server)
         if args.insecure: