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

crossplane/pythonic/__about__.py

@@ -1,2 +1,2 @@
 # This is set at build time, using "hatch version"
-__version__ = "0.2.0"
+__version__ = "0.3.0"

crossplane/pythonic/auto_ready.py

@@ -0,0 +1,153 @@
+
+
+def process(composite):
+    for name, resource in composite.resources:
+        if resource.observed:
+            if resource.autoReady or (resource.autoReady is None and composite.autoReady):
+                if resource.ready is None:
+                    if _checks.get((resource.apiVersion, resource.kind), _check_default).ready(resource):
+                        resource.ready = True
+
+
+class ConditionReady:
+    def ready(self, resource):
+        return bool(resource.conditions.Ready.status)
+
+_checks = {}
+_check_default = ConditionReady()
+
+class Check:
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        if hasattr(cls, 'apiVersion'):
+            _checks[(cls.apiVersion, cls.__name__)] = cls()
+
+    def ready(self, resource):
+        raise NotImplementedError()
+
+class AlwaysReady(Check):
+    def ready(self, resource):
+        return True
+
+
+class ClusterRole(AlwaysReady):
+    apiVersion = 'rbac.authorization.k8s.io/v1'
+
+class ClusterRoleBinding(AlwaysReady):
+    apiVersion = 'rbac.authorization.k8s.io/v1'
+
+class ConfigMap(AlwaysReady):
+    apiVersion = 'v1'
+
+class CronJob(Check):
+    apiVersion = 'batch/v1'
+    def ready(self, resource):
+        if resource.observed.spec.suspend and len(resource.observed.spec.suspend):
+            return True
+        if not resource.status.lastScheduleTime:
+            return False
+        if resource.status.active:
+            return True
+        if not resource.status.lastSuccessfulTime:
+            return False
+        return str(resource.status.lastSuccessfulTime) >= str(resource.status.lastScheduleTime)
+
+class DaemonSet(Check):
+    apiVersion = 'apps/v1'
+    def ready(self, resource):
+        if not resource.status.desiredNumberScheduled:
+            return False
+        scheduled = resource.status.desiredNumberScheduled
+        return (scheduled == resource.status.numberReady and
+                scheduled == resource.status.updatedNumberScheduled and
+                scheduled == resource.status.numberAvailable
+                )
+
+class Deployment(Check):
+    apiVersion = 'apps/v1'
+    def ready(self, resource):
+        replicas = resource.observed.spec.replicas or 1
+        if resource.status.updatedReplicas != replicas or resource.status.availableReplicas != replicas:
+            return False
+        return bool(resource.conditions.Available.status)
+
+class HorizontalPodAutoscaler(Check):
+    apiVersion = 'autoscaling/v2'
+    def ready(self, resource):
+        for type in ('FailedGetScale', 'FailedUpdateScale', 'FailedGetResourceMetric', 'InvalidSelector'):
+            if resource.conditions[type].status:
+                return False
+        for type in ('ScalingActive', 'ScalingLimited'):
+            if resource.conditions[type].status:
+                return True
+        return False
+
+class Ingress(Check):
+    apiVersion = 'networking.k8s.io/v1'
+    def ready(self, resource):
+        return len(resource.status.loadBalancer.ingress) > 0
+
+class Job(Check):
+    apiVersion = 'batch/v1'
+    def ready(self, resource):
+        for type in ('Failed', 'Suspended'):
+            if resource.conditions[type].status:
+                return False
+        return bool(resource.conditions.Complete.status)
+
+class Namespace(AlwaysReady):
+    apiVersion = 'v1'
+
+class PersistentVolumeClaim(Check):
+    apiVersion = 'v1'
+    def ready(self, resource):
+        return resource.status.phase == 'Bound'
+
+class Pod(Check):
+    apiVersion = 'v1'
+    def ready(self, resource):
+        if resource.status.phase == 'Succeeded':
+            return True
+        if resource.status.phase == 'Running':
+            if resource.observed.spec.restartPolicy == 'Always':
+                if resource.conditions.Ready.status:
+                    return True
+        return False
+
+class ReplicaSet(Check):
+    apiVersion = 'v1'
+    def ready(self, resource):
+        if int(resource.status.observedGeneration) < int(resource.observed.metadata.generation):
+            return False
+        if resource.conditions.ReplicaFailure.status:
+            return False
+        return int(resource.status.availableReplicas) >= int(resource.observed.spec.replicas or 1)
+
+class Role(AlwaysReady):
+    apiVersion = 'rbac.authorization.k8s.io/v1'
+
+class RoleBinding(AlwaysReady):
+    apiVersion = 'rbac.authorization.k8s.io/v1'
+
+class Secret(AlwaysReady):
+    apiVersion = 'v1'
+
+class Service(Check):
+    apiVersion = 'v1'
+    def ready(self, resource):
+        if resource.observed.spec.type != 'LoadBalancer':
+            return True
+        return len(resource.status.loadBalancer.ingress) > 0
+
+class ServiceAccount(AlwaysReady):
+    apiVersion = 'v1'
+
+class StatefulSet(Check):
+    apiVersion = 'apps/v1'
+    def ready(self, resource):
+        replicas = resource.observed.spec.replicas or 1
+        return (resource.status.readyReplicas == replicas and
+                resource.status.currentReplicas == replicas and
+                resource.status.currentRevision == resource.status.updateRevision
+                )

crossplane/pythonic/command.py

@@ -50,6 +50,11 @@ class Command:
             action='store_true',
             help='Allow oversized protobuf messages',
         )
+        parser.add_argument(
+            '--crossplane-v1',
+            action='store_true',
+            help='Enable Crossplane V1 compatibility mode',
+        )
 
     def __init__(self, args):
         self.args = args

crossplane/pythonic/composite.py

@@ -9,8 +9,86 @@ from . import protobuf
 _notset = object()
 
 
+class ConnectionSecret:
+    def __get__(self, composite, objtype=None):
+        if composite.crossplane_v1:
+            return composite.spec.writeConnectionSecretToRef
+        secret = getattr(composite, '_connectionSecret', None)
+        if not secret:
+            secret = protobuf.Map()
+            for key, value in composite.request.input.writeConnectionSecretToRef:
+                secret[key] = value
+            composite._connectionSecret = secret
+        return secret
+
+    def __set__(self, composite, values):
+        if composite.crossplane_v1:
+            if values != composite.spec.writeConnectionSecretToRef:
+                raise NotImplementedError('Connection Secret cannot be set in Crossplane V1')
+            return
+        secret = protobuf.Map()
+        for key, value in values:
+            secret[key] = value
+        composite._connectionSecret = secret
+
+
+class Connection:
+    def __get__(self, composite, objtype=None):
+        connection = getattr(composite, '_connection', None)
+        if not connection:
+            connection = _Connection(composite)
+            composite._connection = connection
+        return connection
+
+    def __set__(self, composite, values):
+        connection = self.__get__(composite)
+        coneection()
+        for key, value in values:
+            connection[key] = value
+
+
+class TTL:
+    def __get__(self, composite, objtype=None):
+        if composite.response.meta.ttl.nanos:
+            return float(composite.response.meta.ttl.seconds) + (float(composite.response.meta.ttl.nanos) / 1000000000.0)
+        return int(composite.response.meta.ttl.seconds)
+
+    def __set__(self, composite, ttl):
+        if isinstance(ttl, int):
+            composite.response.meta.ttl.seconds = ttl
+            composite.response.meta.ttl.nanos = 0
+        elif isinstance(ttl, float):
+            composite.response.meta.ttl.seconds = int(ttl)
+            if ttl.is_integer():
+                composite.response.meta.ttl.nanos = 0
+            else:
+                composite.response.meta.ttl.nanos = int((ttl - int(composite.response.meta.ttl.seconds)) * 1000000000)
+        else:
+            raise ValueError('ttl must be an int or float')
+
+
+class Ready:
+    def __get__(self, composite, objtype=None):
+        ready = composite.desired._parent.ready
+        if ready == fnv1.Ready.READY_TRUE:
+            return True
+        if ready == fnv1.Ready.READY_FALSE:
+            return False
+        return None
+
+    def __set__(self, composite, ready):
+        if ready:
+            ready = fnv1.Ready.READY_TRUE
+        elif ready == None or (isinstance(ready, protobuf.Value) and ready._isUnknown):
+            ready = fnv1.Ready.READY_UNSPECIFIED
+        else:
+            ready = fnv1.Ready.READY_FALSE
+        composite.desired._parent.ready = ready
+
+
 class BaseComposite:
-    def __init__(self, request, single_use, logger):
+    def __init__(self, crossplane_v1, request, single_use, logger):
+        self.crossplane_v1 = crossplane_v1
         self.request = protobuf.Message(None, 'request', request.DESCRIPTOR, request, 'Function Request')
         response = fnv1.RunFunctionResponse(
             meta=fnv1.ResponseMeta(
@@ -50,54 +128,10 @@ class BaseComposite:
         self.results = Results(self.response)
         self.events = Results(self.response) # Deprecated, use self.results
 
-    @property
-    def ttl(self):
-        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):
-        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 connection(self):
-        return self.response.desired.composite.connection_details
-
-    @connection.setter
-    def connection(self, connection):
-        self.response.desired.composite.connection_details()
-        for key, value in connection:
-            self.response.desired.composite.connection_details[key] = value
-
-    @property
-    def ready(self):
-        ready = self.desired._parent.ready
-        if ready == fnv1.Ready.READY_TRUE:
-            return True
-        if ready == fnv1.Ready.READY_FALSE:
-            return False
-        return None
-
-    @ready.setter
-    def ready(self, ready):
-        if ready:
-            ready = fnv1.Ready.READY_TRUE
-        elif ready == None or (isinstance(ready, protobuf.Value) and ready._isUnknown):
-            ready = fnv1.Ready.READY_UNSPECIFIED
-        else:
-            ready = fnv1.Ready.READY_FALSE
-        self.desired._parent.ready = ready
+    ttl = TTL()
+    connectionSecret = ConnectionSecret()
+    connection = Connection()
+    ready = Ready()
 
     async def compose(self):
         raise NotImplementedError()
@@ -262,6 +296,14 @@ class Resource:
     def spec(self, spec):
         self.desired.spec = spec
 
+    @property
+    def type(self):
+        return self.desired.type
+
+    @type.setter
+    def type(self, type):
+        self.desired.type = type
+
     @property
     def data(self):
         return self.desired.data
@@ -314,25 +356,43 @@ class Requireds:
 
     def __len__(self):
         names = set()
-        for name, resource in self._composite.request.extra_resources:
-            names.add(name)
-        for name, resource in self._composite.response.requirements.extra_resources:
-            names.add(name)
+        if self._composite.crossplane_v1:
+            for name, resource in self._composite.request.extra_resources:
+                names.add(name)
+            for name, resource in self._composite.response.requirements.extra_resources:
+                names.add(name)
+        else:
+            for name, resource in self._composite.request.required_resources:
+                names.add(name)
+            for name, resource in self._composite.response.requirements.resources:
+                names.add(name)
         return len(names)
 
     def __contains__(self, key):
-        if key in self._composite.request.extra_resources:
-            return True
-        if key in self._composite.response.desired.resources:
-            return True
+        if self._composite.crossplane_v1:
+            if key in self._composite.request.extra_resources:
+                return True
+            if key in self._composite.response.requirements.extra_resources:
+                return True
+        else:
+            if key in self._composite.request.required_resources:
+                return True
+            if key in self._composite.response.requirements.resources:
+                return True
         return False
 
     def __iter__(self):
         names = set()
-        for name, resource in self._composite.request.extra_resources:
-            names.add(name)
-        for name, resource in self._composite.response.requirements.extra_resources:
-            names.add(name)
+        if self._composite.crossplane_v1:
+            for name, resource in self._composite.request.extra_resources:
+                names.add(name)
+            for name, resource in self._composite.response.requirements.extra_resources:
+                names.add(name)
+        else:
+            for name, resource in self._composite.request.required_resources:
+                names.add(name)
+            for name, resource in self._composite.response.requirements.resources:
+                names.add(name)
         for name in sorted(names):
             yield name, self[name]
 
@@ -340,8 +400,12 @@ class Requireds:
 class RequiredResources:
     def __init__(self, composite, name):
         self.name = name
-        self._selector = composite.response.requirements.extra_resources[name]
-        self._resources = composite.request.extra_resources[name]
+        if composite.crossplane_v1:
+            self._selector = composite.response.requirements.extra_resources[name]
+            self._resources = composite.request.extra_resources[name]
+        else:
+            self._selector = composite.response.requirements.resources[name]
+            self._resources = composite.request.required_resources[name]
         self._cache = {}
 
     def __call__(self, apiVersion=_notset, kind=_notset, namespace=_notset, name=_notset, labels=_notset):
@@ -431,9 +495,11 @@ class RequiredResource:
         self.kind = self.observed.kind
         self.metadata = self.observed.metadata
         self.spec = self.observed.spec
+        self.type = self.observed.type
         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)
@@ -721,3 +787,119 @@ class Result:
                 self._result.target = fnv1.Target.TARGET_UNSPECIFIED
             else:
                 self._result.target = fnv1.Target.TARGET_COMPOSITE
+
+
+class _Connection:
+    def __init__(self, composite):
+        self._set_attribute('_composite', composite)
+
+    def _set_attribute(self, key, value):
+        self.__dict__[key] = value
+
+    @property
+    def _resource_name(self):
+        return self._composite.connectionSecret.resourceName or 'connection-secret'
+
+    @property
+    def observed(self):
+        if self._composite.crossplane_v1:
+            return self._composite.response.observed.composite.connection_details
+        data = protobuf.Map()
+        for key, value in self._composite.resources[self._resource_name].observed.data:
+            data[key] = protobuf.B64Decode(value)        
+        return data
+
+    def __getattr__(self, key):
+        return self[key]
+
+    def __getitem__(self, key):
+        if self._composite.crossplane_v1:
+            return self._composite.response.desired.composite.connection_details[key]
+        value = self._composite.resources[self._resource_name].data[key]
+        if value:
+            value = protobuf.B64Decode(value)
+        return value
+
+    def __bool__(self):
+        if self._composite.crossplane_v1:
+            return bool(self._composite.response.desired.composite.connection_details)
+        return bool(self._composite.resources[self._resource_name].data)
+
+    def __len__(self):
+        if self._composite.crossplane_v1:
+            return len(self._composite.response.desired.composite.connection_details)
+        return len(self._composite.resources[self._resource_name].data)
+
+    def __contains__(self, key):
+        if self._composite.crossplane_v1:
+            return key in self._composite.response.desired.composite.connection_details
+
+    def __iter__(self):
+        keys = set()
+        if self._composite.crossplane_v1:
+            for key, value in self._composite.response.desired.composite.connection_details:
+                yield key, value
+        for key, value in self._composite.resources[self._resource_name].data:
+            yield key, protobuf.B64Decode(value)
+
+    def __str__(self):
+        return format(self)
+
+    def __format__(self, spec='yaml'):
+        if self._composite.crossplane_v1:
+            return format(self._composite.response.desired.composite.connection_details, spec)
+        data = protobuf.Map()
+        for key, value in self._composite.resources[self._resource_name].data:
+            data[key] = protobuf.B64Decode(value)
+        return format(data, spec)
+
+    def __call__(self, **kwargs):
+        if self._composite_v1:
+            self._composite.response.desired.composite.connection_details(**kwargs)
+            return
+        del self._composite.resources[self._resource_name]
+        for key, value in kwargs:
+            self[key] = value
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def __setitem__(self, key, value):
+        if not isinstance(value, str):
+            if value is None:
+                return
+            if isinstance(value, (protobuf.FieldMessage, protobuf.Value)):
+                if not value:
+                    return
+            value = str(value)
+        if self._composite.crossplane_v1:
+            self._composite.response.desired.composite.connection_details[key] = value
+            return
+        #if not self._composite.connectionSecret.name:
+        #    return
+        if self._resource_name in self._composite.resources:
+            secret = self._composite.resources[self._resource_name]
+        else:
+            secret = self._composite.resources[self._resource_name]('v1', 'Secret')
+            print(bool(self._composite.connectionSecret.name), len(self._composite.connectionSecret.name))
+            if self._composite.connectionSecret.name and len(self._composite.connectionSecret.name):
+                secret.metadata.name = self._composite.connectionSecret.name
+            if not self._composite.metadata.namespace:
+                if not self._composite.connectionSecret.namespace:
+                    self._composite.results.fatal('ConnectionNoNamespace', 'Cluster scoped XR must specify connection secret namespace')
+                    return
+                secret.metadata.namespace = self._composite.connectionSecret.namespace
+            secret.type = 'connection.crossplane.io/v1alpha1'
+        secret.data[key] = protobuf.B64Encode(value)
+
+    def __delattr__(self, key):
+        del self[key]
+
+    def __delitem__(self, key):
+        if self._composite.crossplane_v1:
+            del self._composite.response.desired.composite.connection_details[key]
+            return
+        if self._resource_name in self._composite.resources:
+            del self._composite.resources[self._resource_name].data[key]
+            if not len(self._composite.resources[self._resource_name].data):
+                del self._composite.resources[self._resource_name]

crossplane/pythonic/function.py

@@ -9,6 +9,7 @@ import sys
 import grpc
 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 auto_ready
 from .. import pythonic
 
 logger = logging.getLogger(__name__)
@@ -17,10 +18,11 @@ logger = logging.getLogger(__name__)
 class FunctionRunner(grpcv1.FunctionRunnerService):
     """A FunctionRunner handles gRPC RunFunctionRequests."""
 
-    def __init__(self, debug=False, renderUnknowns=False):
+    def __init__(self, debug=False, renderUnknowns=False, crossplane_v1=False):
         """Create a new FunctionRunner."""
         self.debug = debug
         self.renderUnknowns = renderUnknowns
+        self.crossplane_v1 = crossplane_v1
         self.clazzes = {}
 
     def invalidate_module(self, module):
@@ -100,7 +102,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
             self.clazzes[composite] = clazz
 
         try:
-            composite = clazz(request, single_use, logger)
+            composite = clazz(self.crossplane_v1, request, single_use, logger)
         except Exception as e:
             return self.fatal(request, logger, 'Instantiate', e)
 
@@ -122,7 +124,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         else:
             self.process_usages(composite)
             self.process_unknowns(composite)
-            self.process_auto_readies(composite)
+            auto_ready.process(composite)
             logger.info('Completed compose')
 
         return composite.response._message
@@ -152,11 +154,11 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
     def get_requireds(self, step, composite):
         requireds = []
         for name, required in composite.requireds:
-            if required.apiVersion and required.kind:
+            if len(required.apiVersion) and len(required.kind):
                 r = pythonic.Map(apiVersion=required.apiVersion, kind=required.kind)
-                if required.namespace:
+                if len(required.namespace):
                     r.namespace = required.namespace
-                if required.matchName:
+                if len(required.matchName):
                     r.matchName = required.matchName
                 for key, value in required.matchLabels:
                     r.matchLabels[key] = value
@@ -166,6 +168,10 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         return requireds
 
     def process_usages(self, composite):
+        if self.crossplane_v1:
+            apiVersion = 'apiextensions.crossplane.io/v1beta1'
+        else:
+            apiVersion = 'protection.crossplane.io/v1beta1'
         for _, resource in sorted(entry for entry in composite.resources):
             dependencies = resource.desired._getDependencies
             if dependencies:
@@ -175,7 +181,6 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                         source = self.trimFullName(source)
                         composite.logger.debug(f"Dependency: {destination} = {source}")
                 if resource.usages or (resource.usages is None and composite.usages):
-                    apiVersion = 'protection.crossplane.io/v1beta1' if composite.metadata.namespace else 'apiextensions.crossplane.io/v1beta1'
                     resources = {}
                     requireds = {}
                     for destination, source in sorted(dependencies.items()):
@@ -191,7 +196,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                             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[1] in ('required_resources', 'extra_resources') and
                             name[3].startswith('items[') and name[3][-1] == ']' and
                             name[4] == 'resource'
                         ):
@@ -206,8 +211,6 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                             name.append(str(source.metadata.namespace))
                         name.append(str(source.observed.metadata.name))
                         usage = composite.resources['_'.join(name)](apiVersion, '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
@@ -215,9 +218,17 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                         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
+                        if not self.crossplane_v1:
+                            if composite.metadata.namespace:
+                                if source.metadata.namespace and source.metadata.namespace != composite.metadata.namespace:
+                                    usage.spec.of.resourceRef.namespace = source.metadata.namespace
+                            elif resource.metadata.namespace:
+                                usage.metadata.namespace = resource.metadata.namespace
+                                if source.metadata.namespace and source.metadata.namespace != resource.metadata.namespace:
+                                    usage.spec.of.resourceRef.namespace = source.metadata.namespace
+                            else:
+                                usage.kind = 'ClusterUsage'
                     for key, dependencies in requireds.items():
                         source = composite.requireds[key[0]][key[1]]
                         name = [resource.name, str(source.kind)]
@@ -225,8 +236,6 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                             name.append(str(source.metadata.namespace))
                         name.append(str(source.metadata.name))
                         usage = composite.resources['_'.join(name)](apiVersion, '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
@@ -234,9 +243,17 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
                         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
+                        if not self.crossplane_v1:
+                            if composite.metadata.namespace:
+                                if source.metadata.namespace and source.metadata.namespace != composite.metadata.namespace:
+                                    usage.spec.of.resourceRef.namespace = source.metadata.namespace
+                            elif resource.metadata.namespace:
+                                usage.metadata.namespace = resource.metadata.namespace
+                                if source.metadata.namespace and source.metadata.namespace != resource.metadata.namespace:
+                                    usage.spec.of.resourceRef.namespace = source.metadata.namespace
+                            else:
+                                usage.kind = 'ClusterUsage'
 
     def process_unknowns(self, composite):
         unknownResources = []
@@ -301,13 +318,6 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         if result:
             result(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
-
     def trimFullName(self, name):
         name = name.split('.')
         for values in (