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

crossplane/pythonic/__about__.py

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

crossplane/pythonic/__main__.py

@@ -0,0 +1,2 @@
+from . import main
+main.main()

crossplane/pythonic/command.py

@@ -0,0 +1,102 @@
+
+import logging
+import pathlib
+import sys
+
+
+class Command:
+    name = None
+    command = None
+    description = None
+
+    @classmethod
+    def create(cls, subparsers):
+        parser = subparsers.add_parser(cls.name, help=cls.help, description=cls.description)
+        parser.set_defaults(command=cls)
+        cls.add_parser_arguments(parser)
+
+    @classmethod
+    def add_parser_arguments(cls, parser):
+        pass
+
+    @classmethod
+    def add_function_arguments(cls, parser):
+        parser.add_argument(
+            '--debug', '-d',
+            action='store_true',
+            help='Emit debug logs.',
+        )
+        parser.add_argument(
+            '--log-name-width',
+            type=int,
+            default=40,
+            metavar='WIDTH',
+            help='Width of the logger name in the log output, default 40.',
+        )
+        parser.add_argument(
+            '--python-path',
+            action='append',
+            default=[],
+            metavar='DIRECTORY',
+            help='Filing system directories to add to the python path.',
+        )
+        parser.add_argument(
+            '--render-unknowns', '-u',
+            action='store_true',
+            help='Render resources with unknowns, useful during local development.'
+        )
+        parser.add_argument(
+            '--allow-oversize-protos',
+            action='store_true',
+            help='Allow oversized protobuf messages',
+        )
+
+    def __init__(self, args):
+        self.args = args
+        self.initialize()
+
+    def initialize(self):
+        pass
+
+    def initialize_function(self):
+        formatter = Formatter(self.args.log_name_width)
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(formatter)
+        logger = logging.getLogger()
+        logger.handlers = [handler]
+        logger.setLevel(logging.DEBUG if self.args.debug else logging.INFO)
+
+        for path in reversed(self.args.python_path):
+            sys.path.insert(0, str(pathlib.Path(path).expanduser().resolve()))
+
+        if self.args.allow_oversize_protos:
+            from google.protobuf.internal import api_implementation
+            if api_implementation._c_module:
+                api_implementation._c_module.SetAllowOversizeProtos(True)
+
+    async def run(self):
+        raise NotImplementedError()
+
+
+class Formatter(logging.Formatter):
+    def __init__(self, name_width):
+        super(Formatter, self).__init__(
+            f"[{{asctime}}.{{msecs:03.0f}}] {{sname:{name_width}.{name_width}}} [{{levelname:8.8}}] {{message}}",
+            '%Y-%m-%d %H:%M:%S',
+            '{',
+        )
+        self.name_width = name_width
+
+    def format(self, record):
+        record.sname = record.name
+        extra = len(record.sname) - self.name_width
+        if extra > 0:
+            names = record.sname.split('.')
+            for ix, name in enumerate(names):
+                if len(name) > extra:
+                    names[ix] = name[extra:]
+                    break
+                names[ix] = name[:1]
+                extra -= len(name) - 1
+            record.sname = '.'.join(names)
+        return super(Formatter, self).format(record)

crossplane/pythonic/composite.py

@@ -47,7 +47,8 @@ class BaseComposite:
         self.spec = self.observed.spec
         self.status = self.desired.status
         self.conditions = Conditions(observed, self.response)
-        self.events = Events(self.response)
+        self.results = Results(self.response)
+        self.events = Results(self.response) # Deprecated, use self.results
 
     @property
     def ttl(self):
@@ -449,6 +450,32 @@ class Conditions:
     def __getitem__(self, type):
         return Condition(self, type)
 
+    def __bool__(self):
+        if self._response is not None:
+            if self._response.conditions:
+                return True
+        if self._observed.resource.status.conditions:
+            return True
+        return False
+
+    def __len__(self):
+        return len(self._types())
+
+    def __iter__(self):
+        for type in self._types():
+            yield self[type]
+
+    def _types(self):
+        types = set()
+        if self._response is not None:
+            for condition in self._response.conditions:
+                if condition.type:
+                    types.add(str(condition.type))
+        for condition in self._observed.resource.status.conditions:
+            if condition.type:
+                types.add(str(condition.type))
+        return sorted(types)
+
 
 class Condition(protobuf.ProtobufValue):
     def __init__(self, conditions, type):
@@ -567,42 +594,42 @@ class Condition(protobuf.ProtobufValue):
         return self._conditions._response.conditions.append(condition)
 
 
-class Events:
+class Results:
     def __init__(self, response):
         self._results = response.results
 
     def info(self, reason=_notset, message=_notset, claim=_notset):
-        event = Event(self._results.append())
-        event.info = True
+        result = Result(self._results.append())
+        result.info = True
         if reason != _notset:
-            event.reason = reason
+            result.reason = reason
         if message != _notset:
-            event.message = message
+            result.message = message
         if claim != _notset:
-            event.claim = claim
-        return event
+            result.claim = claim
+        return result
 
     def warning(self, reason=_notset, message=_notset, claim=_notset):
-        event = Event(self._results.append())
-        event.warning = True
+        result = Result(self._results.append())
+        result.warning = True
         if reason != _notset:
-            event.reason = reason
+            result.reason = reason
         if message != _notset:
-            event.message = message
+            result.message = message
         if claim != _notset:
-            event.claim = claim
-        return event
+            result.claim = claim
+        return result
 
     def fatal(self, reason=_notset, message=_notset, claim=_notset):
-        event = Event(self._results.append())
-        event.fatal = True
+        result = Result(self._results.append())
+        result.fatal = True
         if reason != _notset:
-            event.reason = reason
+            result.reason = reason
         if message != _notset:
-            event.message = message
+            result.message = message
         if claim != _notset:
-            event.claim = claim
-        return event
+            result.claim = claim
+        return result
 
     def __bool__(self):
         return len(self) > 0
@@ -612,15 +639,15 @@ class Events:
 
     def __getitem__(self, key):
         if key >= len(self._results):
-            return Event()
-        return Event(self._results[key])
+            return Result()
+        return Result(self._results[key])
 
     def __iter__(self):
         for ix in range(len(self._results)):
             yield self[ix]
 
 
-class Event:
+class Result:
     def __init__(self, result=None):
         self._result = result
 

crossplane/pythonic/function.py

@@ -24,10 +24,14 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         self.clazzes = {}
 
     def invalidate_module(self, module):
-        self.clazzes.clear()
-        if module in sys.modules:
-            del sys.modules[module]
+        ix = len(module)
+        while ix > 0:
+            module = module[:ix]
+            if module in sys.modules:
+                del sys.modules[module]
+            ix = module.rfind('.')
         importlib.invalidate_caches()
+        self.clazzes.clear()
 
     async def RunFunction(
         self, request: fnv1.RunFunctionRequest, _: grpc.aio.ServicerContext
@@ -44,7 +48,7 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
         name.append(composite['metadata']['name'])
         logger = logging.getLogger('.'.join(name))
 
-        if composite['apiVersion'] == 'pythonic.fortra.com/v1alpha1' and composite['kind'] == 'Composite':
+        if composite['apiVersion'] in ('pythonic.crossplane.io/v1alpha1', 'pythonic.fortra.com/v1alpha1') and composite['kind'] == 'Composite':
             if 'spec' not in composite or 'composite' not in composite['spec']:
                 return self.fatal(request, logger, 'Missing spec "composite"')
             single_use = True
@@ -272,30 +276,30 @@ class FunctionRunner(grpcv1.FunctionRunnerService):
             reason = 'FatalUnknowns'
             message = f"Observed resources with unknowns: {','.join(fatalResources)}"
             status = False
-            event = composite.events.fatal
+            result = composite.results.fatal
         elif warningResources:
             level = composite.logger.warning
             reason = 'ObservedUnknowns'
             message = f"Observed resources with unknowns: {','.join(warningResources)}"
             status = False
-            event = composite.events.warning
+            result = composite.results.warning
         elif unknownResources:
             level = composite.logger.info
             reason = 'DesiredUnknowns'
             message = f"Desired resources with unknowns: {','.join(unknownResources)}"
             status = False
-            event = composite.events.info
+            result = composite.results.info
         else:
             level = None
             reason = 'AllComposed'
             message = 'All resources are composed'
             status = True
-            event = None
+            result = None
         if not self.debug and level:
             level(message)
         composite.conditions.ResourcesComposed(reason, message, status)
-        if event:
-            event(reason, message)
+        if result:
+            result(reason, message)
 
     def process_auto_readies(self, composite):
         for name, resource in composite.resources:

crossplane/pythonic/grpc.py

@@ -0,0 +1,123 @@
+
+import asyncio
+import os
+import pathlib
+import shlex
+import signal
+import sys
+
+import crossplane.function.proto.v1.run_function_pb2_grpc as grpcv1
+import grpc
+
+from . import (
+    command,
+    function,
+)
+
+
+class Command(command.Command):
+    name = 'grpc'
+    help = 'Run function-pythonic gRPC server'
+
+    @classmethod
+    def add_parser_arguments(cls, parser):
+        cls.add_function_arguments(parser)
+        parser.add_argument(
+            '--address',
+            default='0.0.0.0:9443',
+            help='Address to listen on for gRPC connections, default: 0.0.0.0:9443',
+        )
+        parser.add_argument(
+            '--tls-certs-dir',
+            default=os.getenv('TLS_SERVER_CERTS_DIR'),
+            metavar='DIRECTORY',
+            help='Serve using TLS certificates.',
+        )
+        parser.add_argument(
+            '--insecure',
+            action='store_true',
+            help='Run without mTLS credentials, --tls-certs-dir will be ignored.',
+        )
+        parser.add_argument(
+            '--packages',
+            action='store_true',
+            help='Discover python packages from function-pythonic ConfigMaps.'
+        )
+        parser.add_argument(
+            '--packages-secrets',
+            action='store_true',
+            help='Also Discover python packages from function-pythonic Secrets.'
+        )
+        parser.add_argument(
+            '--packages-namespace',
+            action='append',
+            default=[],
+            metavar='NAMESPACE',
+            help='Namespaces to discover function-pythonic ConfigMaps in, default is cluster wide.',
+        )
+        parser.add_argument(
+            '--packages-dir',
+            default='./pythonic-packages',
+            metavar='DIRECTORY',
+            help='Directory to store discovered function-pythonic ConfigMaps to, defaults "<cwd>/pythonic-packages"'
+        )
+        parser.add_argument(
+            '--pip-install',
+            metavar='INSTALL',
+            help='Pip install command to install additional Python packages.'
+        )
+
+    def initialize(self):
+        if not self.args.tls_certs_dir and not self.args.insecure:
+            print('Either --tls-certs-dir or --insecure must be specified', file=sys.stderr)
+            sys.exit(1)
+
+        if self.args.pip_install:
+            import pip._internal.cli.main
+            pip._internal.cli.main.main(['install', '--user', *shlex.split(self.args.pip_install)])
+
+        self.initialize_function()
+
+        # enables read only volumes or mismatched uid volumes
+        sys.dont_write_bytecode = True
+
+    async def run(self):
+        grpc.aio.init_grpc_aio()
+        grpc_runner = function.FunctionRunner(self.args.debug, self.args.render_unknowns)
+        grpc_server = grpc.aio.server()
+        grpcv1.add_FunctionRunnerServiceServicer_to_server(grpc_runner, grpc_server)
+        if self.args.insecure:
+            grpc_server.add_insecure_port(self.args.address)
+        else:
+            certs = pathlib.Path(self.args.tls_certs_dir).expanduser().resolve()
+            grpc_server.add_secure_port(
+                self.args.address,
+                grpc.ssl_server_credentials(
+                    private_key_certificate_chain_pairs=[(
+                        (certs / 'tls.key').read_bytes(),
+                        (certs / 'tls.crt').read_bytes(),
+                    )],
+                    root_certificates=(certs / 'ca.crt').read_bytes(),
+                    require_client_auth=True,
+                ),
+            )
+        await grpc_server.start()
+
+        if self.args.packages:
+            from . import packages
+            async with asyncio.TaskGroup() as tasks:
+                tasks.create_task(grpc_server.wait_for_termination())
+                tasks.create_task(packages.operator(
+                    grpc_server,
+                    grpc_runner,
+                    self.args.packages_secrets,
+                    self.args.packages_namespace,
+                    self.args.packages_dir,
+                ))
+        else:
+            def stop():
+                asyncio.ensure_future(grpc_server.stop(5))
+            loop = asyncio.get_event_loop()
+            loop.add_signal_handler(signal.SIGINT, stop)
+            loop.add_signal_handler(signal.SIGTERM, stop)
+            await grpc_server.wait_for_termination()

crossplane/pythonic/main.py

@@ -1,197 +1,27 @@
-"""The composition function's main CLI."""
+"""The function-pythonic's main CLI."""
 
 import argparse
 import asyncio
-import logging
-import os
-import pathlib
-import shlex
-import signal
 import sys
-import traceback
 
-import crossplane.function.logging
-import crossplane.function.proto.v1.run_function_pb2_grpc as grpcv1
-import grpc
-
-from . import function
+from . import (
+    grpc,
+    render,
+    version,
+)
 
 
 def main():
-    asyncio.run(Main().main())
-
-
-class Main:
-    async def main(self):
-        parser = argparse.ArgumentParser('Crossplane Function Pythonic')
-        parser.add_argument(
-            '--debug', '-d',
-            action='store_true',
-            help='Emit debug logs.',
-        )
-        parser.add_argument(
-            '--log-name-width',
-            type=int,
-            default=40,
-            metavar='WIDTH',
-            help='Width of the logger name in the log output, default 40',
-        )
-        parser.add_argument(
-            '--address',
-            default='0.0.0.0:9443',
-            help='Address to listen on for gRPC connections, default: 0.0.0.0:9443',
-        )
-        parser.add_argument(
-            '--tls-certs-dir',
-            default=os.getenv('TLS_SERVER_CERTS_DIR'),
-            metavar='DIRECTORY',
-            help='Serve using TLS certificates.',
-        )
-        parser.add_argument(
-            '--insecure',
-            action='store_true',
-            help='Run without mTLS credentials, --tls-certs-dir will be ignored.',
-        )
-        parser.add_argument(
-            '--packages',
-            action='store_true',
-            help='Discover python packages from function-pythonic ConfigMaps.'
-        )
-        parser.add_argument(
-            '--packages-secrets',
-            action='store_true',
-            help='Also Discover python packages from function-pythonic Secrets.'
-        )
-        parser.add_argument(
-            '--packages-namespace',
-            action='append',
-            default=[],
-            metavar='NAMESPACE',
-            help='Namespaces to discover function-pythonic ConfigMaps in, default is cluster wide.',
-        )
-        parser.add_argument(
-            '--packages-dir',
-            default='./pythonic-packages',
-            metavar='DIRECTORY',
-            help='Directory to store discovered function-pythonic ConfigMaps to, defaults "<cwd>/pythonic-packages"'
-        )
-        parser.add_argument(
-            '--pip-install',
-            metavar='COMMAND',
-            help='Pip install command to install additional Python packages.'
-        )
-        parser.add_argument(
-            '--python-path',
-            action='append',
-            default=[],
-            metavar='DIRECTORY',
-            help='Filing system directories to add to the python path',
-        )
-        parser.add_argument(
-            '--allow-oversize-protos',
-            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)
-            sys.exit(1)
-
-        if args.pip_install:
-            import pip._internal.cli.main
-            pip._internal.cli.main.main(['install', '--user', *shlex.split(args.pip_install)])
-
-        for path in reversed(args.python_path):
-            sys.path.insert(0, str(pathlib.Path(path).expanduser().resolve()))
-
-        self.configure_logging(args)
-        # enables read only volumes or mismatched uid volumes
-        sys.dont_write_bytecode = True
-        await self.run(args)
-
-    # Allow for independent running of function-pythonic
-    async def run(self, args):
-        if args.allow_oversize_protos:
-            from google.protobuf.internal import api_implementation
-            if api_implementation._c_module:
-                api_implementation._c_module.SetAllowOversizeProtos(True)
-
-        grpc.aio.init_grpc_aio()
-        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:
-            grpc_server.add_insecure_port(args.address)
-        else:
-            certs = pathlib.Path(args.tls_certs_dir).expanduser().resolve()
-            grpc_server.add_secure_port(
-                args.address,
-                grpc.ssl_server_credentials(
-                    private_key_certificate_chain_pairs=[(
-                        (certs / 'tls.key').read_bytes(),
-                        (certs / 'tls.crt').read_bytes(),
-                    )],
-                    root_certificates=(certs / 'ca.crt').read_bytes(),
-                    require_client_auth=True,
-                ),
-            )
-        await grpc_server.start()
-
-        if args.packages:
-            from . import packages
-            async with asyncio.TaskGroup() as tasks:
-                tasks.create_task(grpc_server.wait_for_termination())
-                tasks.create_task(packages.operator(
-                    grpc_server,
-                    grpc_runner,
-                    args.packages_secrets,
-                    args.packages_namespace,
-                    args.packages_dir,
-                ))
-        else:
-            def stop():
-                asyncio.ensure_future(grpc_server.stop(5))
-            loop = asyncio.get_event_loop()
-            loop.add_signal_handler(signal.SIGINT, stop)
-            loop.add_signal_handler(signal.SIGTERM, stop)
-            await grpc_server.wait_for_termination()
-
-    def configure_logging(self, args):
-        formatter = Formatter(args.log_name_width)
-        handler = logging.StreamHandler()
-        handler.setFormatter(formatter)
-        logger = logging.getLogger()
-        logger.handlers = [handler]
-        logger.setLevel(logging.DEBUG if args.debug else logging.INFO)
-
-
-class Formatter(logging.Formatter):
-    def __init__(self, name_width):
-        super(Formatter, self).__init__(
-            f"[{{asctime}}.{{msecs:03.0f}}] {{sname:{name_width}.{name_width}}} [{{levelname:8.8}}] {{message}}",
-            '%Y-%m-%d %H:%M:%S',
-            '{',
-        )
-        self.name_width = name_width
-
-    def format(self, record):
-        record.sname = record.name
-        extra = len(record.sname) - self.name_width
-        if extra > 0:
-            names = record.sname.split('.')
-            for ix, name in enumerate(names):
-                if len(name) > extra:
-                    names[ix] = name[extra:]
-                    break
-                names[ix] = name[:1]
-                extra -= len(name) - 1
-            record.sname = '.'.join(names)
-        return super(Formatter, self).format(record)
+    parser = argparse.ArgumentParser('Crossplane Function Pythonic')
+    subparsers = parser.add_subparsers(title='Command', metavar='')
+    grpc.Command.create(subparsers)
+    render.Command.create(subparsers)
+    version.Command.create(subparsers)
+    args = parser.parse_args()
+    if not hasattr(args, 'command'):
+        parser.print_help()
+        sys.exit(1)
+    asyncio.run(args.command(args).run())
 
 
 if __name__ == '__main__':

crossplane/pythonic/protobuf.py

@@ -55,7 +55,6 @@ def B64Decode(string):
         string = str(string)
     return base64.b64decode(string.encode('utf-8')).decode('utf-8')
 
-B64Decode = lambda s: base64.b64decode(s.encode('utf-8')).decode('utf-8')
 
 class Message:
     def __init__(self, parent, key, descriptor, message=_Unknown, readOnly=False):
@@ -81,7 +80,7 @@ class Message:
             value = getattr(self._message, key)
         if value is _Unknown and field.has_default_value:
             value = field.default_value
-        if field.label == field.LABEL_REPEATED:
+        if field.is_repeated:
             if field.type == field.TYPE_MESSAGE and field.message_type.GetOptions().map_entry:
                 value = MapMessage(self, key, field.message_type.fields_by_name['value'], value, self._readOnly)
             else:
@@ -450,6 +449,10 @@ class RepeatedMessage:
             raise ValueError(f"{self._readOnly} is read only")
         if self._messages is _Unknown:
             self.__dict__['_messages'] = self._parent._create_child(self._key)
+        if key == append:
+            key = len(self._messages)
+        elif key < 0:
+            key = len(self._messages) + key
         while key >= len(self._messages):
             self._messages.add()
         return self._messages[key]
@@ -1050,6 +1053,10 @@ class Value:
                 values = self._value.list_value.values
             else:
                 values = self._value.values
+            if key == append:
+                key = len(values)
+            elif key < 0:
+                key = len(values) + key
             while key >= len(values):
                 values.add()
             values[key].Clear()