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

crossplane/pythonic/__about__.py

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

crossplane/pythonic/auto_ready.py

@@ -1,20 +1,23 @@
 
+def resource_ready(resource):
+    if not resource.observed:
+        return None
+    return _checks.get((resource.observed.apiVersion, resource.observed.kind), _check_default).ready(resource)
 
-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:
+class ReadyCondition:
     def ready(self, resource):
-        return bool(resource.conditions.Ready.status)
+        ready = resource.conditions.Ready
+        if not ready._find_condition():
+            return None
+        if ready.status:
+            return resource.observed.metadata.name
+        if ready.reason:
+            return resource.status.notReadyCondition[ready.reason]
+        return resource.status.notReadyCondition
 
 _checks = {}
-_check_default = ConditionReady()
+_check_default = ReadyCondition()
 
 class Check:
     @classmethod
@@ -28,7 +31,7 @@ class Check:
 
 class AlwaysReady(Check):
     def ready(self, resource):
-        return True
+        return resource.observed.metadata.name
 
 
 class ClusterRole(AlwaysReady):
@@ -44,57 +47,82 @@ class CronJob(Check):
     apiVersion = 'batch/v1'
     def ready(self, resource):
         if resource.observed.spec.suspend and len(resource.observed.spec.suspend):
-            return True
+            return resource.observed.metadata.name
         if not resource.status.lastScheduleTime:
-            return False
+            return resource.status.lastScheduleTime
         if resource.status.active:
-            return True
+            return resource.observed.metadata.name
         if not resource.status.lastSuccessfulTime:
-            return False
-        return str(resource.status.lastSuccessfulTime) >= str(resource.status.lastScheduleTime)
+            return resource.status.lastSuccessfulTime
+        if str(resource.status.lastSuccessfulTime) < str(resource.status.lastScheduleTime):
+            return resource.status.successfulBeforeSchedule
+        return resource.observed.metadata.name
 
 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
-                )
+        if not scheduled:
+            return scheduled
+        for field in ('numberReady', 'updatedNumberScheduled', 'numberAvailable'):
+            value = resource.status[field]
+            if not value:
+                return value
+            if scheduled != value:
+                return resource.status[f"{field}NotScheduled"]
+        return resource.observed.metadata.name
 
 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)
+        for field in ('updatedReplicas', 'availableReplicas'):
+            value = resource.status[field]
+            if not value:
+                return value
+            if replicas != value:
+                return resource.status[F"{field}NotReplicas"]
+        available = resource.conditions.Available
+        if not available:
+            return resource.status.notAvailable
+        if not available.status:
+            if available.reason:
+                return resource.status.notAvailable[available.reason]
+            return resource.status.notAvailable
+        return resource.observed.metadata.name
 
 class HorizontalPodAutoscaler(Check):
     apiVersion = 'autoscaling/v2'
     def ready(self, resource):
         for type in ('FailedGetScale', 'FailedUpdateScale', 'FailedGetResourceMetric', 'InvalidSelector'):
             if resource.conditions[type].status:
-                return False
+                return resource.status[f"is{type}"]
         for type in ('ScalingActive', 'ScalingLimited'):
             if resource.conditions[type].status:
-                return True
-        return False
+                return resource.observed.metadata.name
+        return resource.status.notScalingActiveOrLimiited
 
 class Ingress(Check):
     apiVersion = 'networking.k8s.io/v1'
     def ready(self, resource):
-        return len(resource.status.loadBalancer.ingress) > 0
+        if not len(resource.status.loadBalancer.ingress):
+            return resource.status.noLoadBalanceIngresses
+        return resource.observed.metadata.name
 
 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)
+                return resource.status[f"is{type}"]
+        complete = resource.conditions.Complete
+        if not complete:
+            return resource.status.notComplete
+        if not complete.status:
+            if complete.reason:
+                return resource.status.notComplete[complete.reason]
+            return resource.status.notComplete
+        return resource.observed.metadata.name
 
 class Namespace(AlwaysReady):
     apiVersion = 'v1'
@@ -102,27 +130,33 @@ class Namespace(AlwaysReady):
 class PersistentVolumeClaim(Check):
     apiVersion = 'v1'
     def ready(self, resource):
-        return resource.status.phase == 'Bound'
+        if resource.status.phase != 'Bound':
+            return resource.status.phaseNotBound
+        return resource.observed.metadata.name
 
 class Pod(Check):
     apiVersion = 'v1'
     def ready(self, resource):
         if resource.status.phase == 'Succeeded':
-            return True
+            return resource.observed.metadata.name
         if resource.status.phase == 'Running':
             if resource.observed.spec.restartPolicy == 'Always':
                 if resource.conditions.Ready.status:
-                    return True
-        return False
+                    return resource.observed.metadata.name
+        return resource.status.notSucceededOrRunning
 
 class ReplicaSet(Check):
     apiVersion = 'v1'
     def ready(self, resource):
         if int(resource.status.observedGeneration) < int(resource.observed.metadata.generation):
-            return False
+            return resource.status.priorObservedGeneration
         if resource.conditions.ReplicaFailure.status:
-            return False
-        return int(resource.status.availableReplicas) >= int(resource.observed.spec.replicas or 1)
+            if resource.conditions.ReplicaFailure.reason:
+                return resource.status.isReplicaFailure[resource.conditions.ReplicaFailure.reason]
+            return resource.status.isReplicaFailure
+        if int(resource.status.availableReplicas) < int(resource.observed.spec.replicas or 1):
+            return resource.status.tooFewavailableReplicas
+        return resource.observed.metadata.name
 
 class Role(AlwaysReady):
     apiVersion = 'rbac.authorization.k8s.io/v1'
@@ -137,8 +171,10 @@ class Service(Check):
     apiVersion = 'v1'
     def ready(self, resource):
         if resource.observed.spec.type != 'LoadBalancer':
-            return True
-        return len(resource.status.loadBalancer.ingress) > 0
+            return resource.observed.metadata.name
+        if not len(resource.status.loadBalancer.ingress):
+            return resource.status.noLoadBalancerIngresses
+        return resource.observed.metadata.name
 
 class ServiceAccount(AlwaysReady):
     apiVersion = 'v1'
@@ -147,7 +183,12 @@ 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
-                )
+        for field in ('readyReplicas', 'currentReplicas'):
+            value = resource.status[field]
+            if not value:
+                return value
+            if replicas != value:
+                return resource.status[F"{field}NotReplicas"]
+        if resource.status.currentRevision != resource.status.updateRevision:
+            return resource.status.currentRevisionNotUpdateReivsion
+        return resource.observed.metadata.name

crossplane/pythonic/command.py

@@ -33,6 +33,13 @@ class Command:
             metavar='WIDTH',
             help='Width of the logger name in the log output, default 40.',
         )
+        parser.add_argument(
+            '--logger-level',
+            action='append',
+            default=[],
+            metavar='LOGGER=LEVEL',
+            help='Logger level, for example: botocore.hooks=INFO',
+        )
         parser.add_argument(
             '--python-path',
             action='append',
@@ -70,6 +77,11 @@ class Command:
         logger = logging.getLogger()
         logger.handlers = [handler]
         logger.setLevel(logging.DEBUG if self.args.debug else logging.INFO)
+        for logger_level in self.args.logger_level:
+            for logger_level in logger_level.split(','):
+                logger_level = logger_level.split('=')
+                if len(logger_level) == 2:
+                    logging.getLogger(logger_level[0]).setLevel(logger_level[1].upper())
 
         for path in reversed(self.args.python_path):
             sys.path.insert(0, str(pathlib.Path(path).expanduser().resolve()))

crossplane/pythonic/composite.py

@@ -3,6 +3,7 @@ import datetime
 from google.protobuf.duration_pb2 import Duration
 from crossplane.function.proto.v1 import run_function_pb2 as fnv1
 
+from . import auto_ready
 from . import protobuf
 
 
@@ -69,21 +70,22 @@ class TTL:
 
 class Ready:
     def __get__(self, composite, objtype=None):
-        ready = composite.desired._parent.ready
-        if ready == fnv1.Ready.READY_TRUE:
+        if hasattr(composite, '_ready'):
+            return composite._ready
+        if composite.desired._parent.ready == fnv1.Ready.READY_TRUE:
             return True
-        if ready == fnv1.Ready.READY_FALSE:
+        if composite.desired._parent.ready == fnv1.Ready.READY_FALSE:
             return False
         return None
 
     def __set__(self, composite, ready):
+        composite._ready = ready
         if ready:
-            ready = fnv1.Ready.READY_TRUE
-        elif ready == None or (isinstance(ready, protobuf.Value) and ready._isUnknown):
-            ready = fnv1.Ready.READY_UNSPECIFIED
+            composite.desired._parent.ready = fnv1.Ready.READY_TRUE
+        elif ready is None:
+            composite.desired._parent.ready = fnv1.Ready.READY_UNSPECIFIED
         else:
-            ready = fnv1.Ready.READY_FALSE
-        composite.desired._parent.ready = ready
+            composite.desired._parent.ready = fnv1.Ready.READY_FALSE
 
 
 class BaseComposite:
@@ -111,9 +113,9 @@ class BaseComposite:
         self.environment = self.context['apiextensions.crossplane.io/environment']
         self.requireds = Requireds(self)
         self.resources = Resources(self)
-        self.unknownsFatal = True
         self.autoReady = True
         self.usages = False
+        self.unknownsFatal = False
 
         observed = self.request.observed.composite
         desired = self.response.desired.composite
@@ -231,6 +233,7 @@ class Resources:
 
 class Resource:
     def __init__(self, composite, name):
+        self._composite = composite
         self.name = name
         observed = composite.request.observed.resources[name]
         desired = composite.response.desired.resources[name]
@@ -238,16 +241,22 @@ class Resource:
         self.desired = desired.resource
         self.conditions = Conditions(observed)
         self.connection = observed.connection_details
-        self.unknownsFatal = None
         self.autoReady = None
         self.usages = None
+        self.unknownsFatal = None
 
-    def __call__(self, apiVersion=_notset, kind=_notset, namespace=_notset, name=_notset):
+    def __call__(self, kind=_notset, apiVersion=_notset, namespace=_notset, name=_notset):
         self.desired()
+        if kind != _notset:
+            # Allow for apiVersion in the first arg and kind in the second arg
+            if '/' in kind or kind == 'v1':
+                if apiVersion != _notset:
+                    self.kind = apiVersion
+                apiVersion = kind
+            else:
+                self.kind = kind
         if apiVersion != _notset:
             self.apiVersion = apiVersion
-        if kind != _notset:
-            self.kind = kind
         if namespace != _notset:
             self.metadata.namespace = namespace
         if name != _notset:
@@ -272,9 +281,12 @@ class Resource:
 
     @property
     def externalName(self):
-        if 'crossplane.io/external-name' in self.metadata.annotations:
-            return self.metadata.annotations['crossplane.io/external-name']
-        return self.observed.metadata.annotations['crossplane.io/external-name']
+        name = self.metadata.annotations['crossplane.io/external-name']
+        if not name:
+            name = self.observed.metadata.annotations['crossplane.io/external-name']
+            if name:
+                self.externalName = name
+        return name
 
     @externalName.setter
     def externalName(self, name):
@@ -296,6 +308,7 @@ class Resource:
     def spec(self, spec):
         self.desired.spec = spec
 
+    # Used by Secret:v1
     @property
     def type(self):
         return self.desired.type
@@ -318,23 +331,60 @@ class Resource:
 
     @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
+        if not hasattr(self, '_ready'):
+            if self.desired._parent.ready == fnv1.Ready.READY_TRUE:
+                self._ready =  True
+            elif self.desired._parent.ready == fnv1.Ready.READY_FALSE:
+                self._ready = False
+            else:
+                self._ready = None
+                if self.autoReady or (self.autoReady is None and self._composite.autoReady):
+                    ready = auto_ready.resource_ready(self)
+                    if ready:
+                        self._ready = ready
+                        self.desired._parent.ready = fnv1.Ready.READY_TRUE
+        return self._ready
 
     @ready.setter
     def ready(self, ready):
+        self._ready = ready
         if ready:
-            ready = fnv1.Ready.READY_TRUE
-        elif ready == None or (isinstance(ready, protobuf.Value) and ready._isUnknown):
-            ready = fnv1.Ready.READY_UNSPECIFIED
+            self.desired._parent.ready = fnv1.Ready.READY_TRUE
+        elif ready is None:
+            self.desired._parent.ready = fnv1.Ready.READY_UNSPECIFIED
         else:
-            ready = fnv1.Ready.READY_FALSE
-        self.desired._parent.ready = ready
+            self.desired._parent.ready = fnv1.Ready.READY_FALSE
 
+    def setReadyCondition(self, type='Ready'):
+        condition = self.conditions[type]
+        if condition.status:
+            self.ready = self.observed.metadata.name
+        else:
+            error = f"not{type}Condition"
+            if condition.reason:
+                self.ready = self.status[error][condition.reason]
+            else:
+                self.ready = self.status[error]
+
+    def addDependency(self, resource, field=_notset):
+        if field is _notset:
+            field = resource.ready
+            if field is None:
+                field = auto_ready.resource_ready(resource)
+                if field is None:
+                    field = False
+                resource.ready = field
+        elif field is None:
+            field = True
+        if not isinstance(field, (protobuf.FieldMessage, protobuf.Value)):
+            if field:
+                field = resource.observed.metadata.name
+            else:
+                if not resource.observed.metadata.name:
+                    field = resource.observed.metadata.name
+                else:
+                    field = resource.status.notReady
+        self.metadata.annotations[f"Dependency{resource.name}"] = field
 
 class Requireds:
     def __init__(self, composite):
@@ -408,12 +458,18 @@ class RequiredResources:
             self._resources = composite.request.required_resources[name]
         self._cache = {}
 
-    def __call__(self, apiVersion=_notset, kind=_notset, namespace=_notset, name=_notset, labels=_notset):
+    def __call__(self, kind=_notset, apiVersion=_notset, namespace=_notset, name=_notset, labels=_notset):
         self._selector()
+        if kind != _notset:
+            # Allow for apiVersion in the first arg and kind in the second arg
+            if '/' in kind or kind == 'v1':
+                if apiVersion != _notset:
+                    self.kind = apiVersion
+                apiVersion = kind
+            else:
+                self.kind = kind
         if apiVersion != _notset:
             self.apiVersion = apiVersion
-        if kind != _notset:
-            self.kind = kind
         if namespace != _notset:
             self.namespace = namespace
         if name != _notset:
@@ -802,60 +858,36 @@ class _Connection:
 
     @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
+        return self._composite.response.observed.composite.connection_details
 
     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
+        return self._composite.response.desired.composite.connection_details[key]
 
     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)
+        return bool(self._composite.response.desired.composite.connection_details)
 
     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)
+        return len(self._composite.response.desired.composite.connection_details)
 
     def __contains__(self, key):
-        if self._composite.crossplane_v1:
-            return key in self._composite.response.desired.composite.connection_details
+        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)
+        for key, value in self._composite.response.desired.composite.connection_details:
+            yield key, 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)
+        return format(self._composite.response.desired.composite.connection_details, spec)
 
     def __call__(self, **kwargs):
+        self._composite.response.desired.composite.connection_details(**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:
@@ -872,16 +904,13 @@ class _Connection:
                 if not value:
                     return
             value = str(value)
-        if self._composite.crossplane_v1:
-            self._composite.response.desired.composite.connection_details[key] = value
+        self._composite.response.desired.composite.connection_details[key] = value
+        if self._composite.crossplane_v1 or not self._composite.connectionSecret.name:
             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:
@@ -896,8 +925,8 @@ class _Connection:
         del self[key]
 
     def __delitem__(self, key):
+        del self._composite.response.desired.composite.connection_details[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]

crossplane/pythonic/function.py

@@ -9,7 +9,6 @@ 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__)
@@ -110,7 +109,13 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         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")
+        if iteration == 1 and not logger.isEnabledFor(logging.DEBUG):
+            if len(composite.context._pythonic) == 1:
+                logger.info('Starting compose')
+            else:
+                logger.info(f"Starting compose, {ordinal(len(composite.context._pythonic))} step")
+        else:
+            logger.debug(f"Starting compose, {ordinal(len(composite.context._pythonic))} step, {ordinal(iteration)} pass")
 
         try:
             result = composite.compose()
@@ -120,11 +125,13 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
             return self.fatal(request, logger, 'Compose', e)
 
         if requireds := self.get_requireds(step, composite):
-            logger.info(f"Requireds requested: {','.join(requireds)}")
+            logger.debug(f"Requireds requested: {','.join(requireds)}")
         else:
             self.process_usages(composite)
             self.process_unknowns(composite)
-            auto_ready.process(composite)
+            # Perform auto ready on all resources.
+            for name, resource in composite.resources:
+                resource.ready
             logger.info('Completed compose')
 
         return composite.response._message
@@ -322,9 +329,11 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         name = name.split('.')
         for values in (
                 ('request', 'observed', 'composite', 'resource'),
+                ('response', 'desired', 'composite', 'resource'),
                 ('request', 'observed', 'resources', None, 'resource'),
-                ('request', 'extra_resources', None, 'items', None, 'resource'),
                 ('response', 'desired', 'resources', None, 'resource'),
+                ('request', 'required_resources', None, 'items', None, 'resource'),
+                ('request', 'extra_resources', None, 'items', None, 'resource'),
         ):
             if len(values) < len(name):
                 ix = 0