Release/5.1.0

.github/workflows/publish.yaml

@@ -13,15 +13,15 @@ env:
   BASE_IMAGE_USER: ghcr.io/driplineorg
   BASE_IMAGE_REPO: dripline-cpp
   DEV_SUFFIX: '-dev'
-  BASE_IMAGE_TAG: 'v2.10.4'
-#  BASE_IMAGE_TAG: 'hf2.10.4'
+  BASE_IMAGE_TAG: 'v2.10.6'
+#  BASE_IMAGE_TAG: 'cancelation'
 #  DEV_SUFFIX: ''
 
 jobs:
 
   test_docker:
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     env:
       TAG: gha-test
@@ -94,7 +94,7 @@ jobs:
 
   build_and_push:
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     if: |
       github.event_name == 'push' ||
@@ -204,6 +204,16 @@ jobs:
           tags: ${{ steps.docker_meta_integration.outputs.tags }}
           platforms: linux/amd64,linux/arm64,linux/arm/v7
 
-      - name: Release
-        uses: softprops/action-gh-release@v2
+      - name: Release with a changelog
+        uses: rasmus-saks/release-a-changelog-action@v1.2.0
         if: ${{ github.event_name == 'push' && contains(github.ref, 'refs/tags/') }}
+        with:
+          github-token: '${{ secrets.GITHUB_TOKEN }}'
+          path: 'changelog.md'
+          title-template: 'dripline-python v{version} -- Release Notes'
+          tag-template: 'v{version}'
+
+      # This should be removed if the use of rasmus-saks/release-a-changelog-action works
+      #- name: Release
+      #  uses: softprops/action-gh-release@v2
+      #  if: ${{ github.event_name == 'push' && contains(github.ref, 'refs/tags/') }}

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.5)  # <3.5 is deprecated by CMake
-project( DriplinePy VERSION 5.0.1 )
+project( DriplinePy VERSION 5.1.0 )
 
 cmake_policy( SET CMP0074 NEW )
 

Dockerfile

@@ -1,9 +1,9 @@
 ARG img_user=ghcr.io/driplineorg
 ARG img_repo=dripline-cpp
 #ARG img_tag=develop
-ARG img_tag=v2.10.4
+ARG img_tag=v2.10.6
 
-FROM ${img_user}/${img_repo}:${img_tag}
+FROM ${img_user}/${img_repo}:${img_tag} AS deps
 
 ## would prefer not to do this, just run ldconfig after the build to get things
 ## into the ld.so.conf cache... use this only when developing and adding libs
@@ -14,7 +14,10 @@ RUN apt-get update && \
     apt-get --fix-missing  -y install \
         libpq-dev && \
     rm -rf /var/lib/apt/lists/* && \
-    pip install ipython pytest
+    pip install ipython pytest &&\
+    pip install aiohttp sqlalchemy psycopg2 PyYAML uuid asteval colorlog
+
+FROM deps
 
 COPY . /usr/local/src_py/
 

bin/dl-serve

@@ -32,7 +32,16 @@ class Serve(dripline.core.ObjectCreator):
         try:
             import colorlog
             modified_format = base_format.format('%(log_color)s', '%(purple)s')
-            self._logging_format = colorlog.ColoredFormatter(modified_format, datefmt=time_format[:-4])
+            self._logging_format = colorlog.ColoredFormatter(modified_format, 
+                                                             datefmt=time_format[:-4],
+                                                             log_colors={
+                                                                 'DEBUG': 'cyan',
+                                                                 'INFO': 'green',
+                                                                 'WARNING': 'yellow',
+                                                                 'ERROR': 'red',
+                                                                 'CRITICAL': 'red,bg_white',
+                                                             },
+                                                             )
         except ImportError:
             modified_format = base_format.format(' ', '')
             self._logging_format = logging.Formatter(modified_format, time_format[:-4])
@@ -52,9 +61,10 @@ class Serve(dripline.core.ObjectCreator):
         this_config_param = the_app.primary_config
         this_auth = the_app.auth
 
-        verbosity = the_app.global_verbosity
+        verbosity = scarab.s2py_verbosity(the_app.global_verbosity)
         #print(f"verbosity is {verbosity}")
         self.handler.setLevel(verbosity)
+        logger.setLevel(verbosity)
 
         sig_handler = scarab.SignalHandler()
 
@@ -74,11 +84,14 @@ class Serve(dripline.core.ObjectCreator):
         # Create the service and register it with the signal handler
         the_service = self.create_object( this_config, 'Service', this_auth )
         sig_handler.add_cancelable(the_service)
+        #scarab.SignalHandler.add_cancelable(the_service)
         logger.info(f'Service {the_service.name} has been built')
 
         # Run the service
         the_service.run()
 
+        scarab.SignalHandler.remove_cancelable(the_service)
+
 if __name__ == '__main__':
     # App object
     the_main = scarab.MainApp()

changelog.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [5.1.0] - 2025-08-26
+
+### Added
+
+- Heartbeat Monitor (implementations.HeartbeatMonitor)
+- New logic for how logging is handled by Entities
+  - The `log_interval` is now the interval with which an entity's value is checked, not necessarily logged
+  - Whether a value is logged at the `log_interval` is controlled by:
+    - `max_interval`: if this time is exceeded since the last log entry, then it will be logged; if 0 (default), then logging occurs every `log_interval`
+    - `max_absolute_change`: if the value changes by more than this since the last log entry, then it will be logged
+    - `max_fractional_change`: if the value changes fractional change is more than this since the last log entry, then it will be logged
+  - The field that's checked for the `max_fractional_change` and `max_absolute_change` is given by `check_field`
+
+### Changed
+
+- Methods for sending and receiving messages are moved to the mixin classes core.RequestHandler and core.RequestSender
+  to capture how dl-py handles requests for both services and endpoints
+- Upgrade dl-cpp to v2.10.6
+- Docker build now separates the installation of dependencies into a separate stage
+
+### Fixed
+
+- Postgres syntax
+- Application cancelation -- can use ctrl-c or other system signals to cancel an executable
+- Alerts exchange not hard-coded in the alerts consumer
+
+## [5.0.1] - 2023-03-05
+
+### Incompatibility
+
+Messages sent with this version of dl-py are not compatible with:
+- dl-py v5.0.0 and earlier
+- dl-py v5.1.0 and later
+- dl-cpp v2.10.3 and earlier
+- dl-cpp v2.10.6 and later.

chart/Chart.yaml

@@ -1,7 +1,7 @@
 apiVersion: v1
 ## the appVersion is used as the container image tag for the main container in the pod from the deployment
 ## it can be overridden by a values.yaml file in image.tag
-appVersion: "v5.0.0"
+appVersion: "v5.1.0"
 description: Deploy a dripline-python microservice
 name: dripline-python
 version: 1.1.2

dripline/core/__init__.py

@@ -9,6 +9,8 @@
 from .entity import *
 from .interface import *
 from .object_creator import *
+from .request_handler import *
+from .request_sender import *
 from .return_codes import *
 from .service import *
 from .throw_reply import *

dripline/core/alert_consumer.py

@@ -35,7 +35,7 @@ def bind_keys(self):
         to_return = Service.bind_keys(self);
         for a_key in self._alert_keys:
             logger.debug(f" binding alert key {a_key}")
-            to_return = to_return and self.bind_key("alerts", a_key)
+            to_return = to_return and self.bind_key(self.alerts_exchange, a_key)
         return to_return
 
     def on_alert_message(self, an_alert):

dripline/core/endpoint.py

@@ -1,8 +1,7 @@
 __all__ = []
 
-import scarab
 from _dripline.core import _Endpoint
-from .throw_reply import ThrowReply
+from .request_handler import RequestHandler
 
 import logging
 
@@ -11,7 +10,7 @@
 __all__.append('Endpoint')
 
 
-class Endpoint(_Endpoint):
+class Endpoint(_Endpoint, RequestHandler):
     '''
     Base class for all objects which can be sent dripline requests.
     Every object described in a runtime configuration passed to `dl-serve` should derive from this class (either directly or indirectly).
@@ -24,88 +23,54 @@ def __init__(self, name):
         '''
         _Endpoint.__init__(self, name)
 
-    def result_to_scarab_payload(self, result: str):
-        """
-        Intercept result values and throw error if scarab is unable to convert to param
-        TODO: Handles global Exception case, could be more specific
+    def do_get_request(self, a_request_message):
+        '''
+        Default function for handling an OP_GET request message addressed to this endpoint.
+
+        .. note: For dripline extension developers -- This function, as defined in RequestHandler, implements the characteristic 
+        dripline-python behavior for an endpoint receiving a get request, including using the specifier to access attributes, 
+        and calling on_get() when there is no specifier.  
+        As an extension author you might typically override RequestReciever.on_get(), but leave this function alone.
+
+        .. note: For core dripline developers -- This function has to be here to correctly receive trampolined calls from 
+        the C++ base class.  It intentionally just calls the version of do_get_request() in RequestHandler.
+
         Args:
-            result (str): request message passed
-        """
-        try:
-            return scarab.to_param(result)
-        except Exception as e:
-            raise ThrowReply('service_error_bad_payload',
-                             f"{self.name} unable to convert result to scarab payload: {result}")
+            a_request_message (MsgRequest): the message receveived by this endpoint
+        '''
 
-    def do_get_request(self, a_request_message):
-        logger.info("in do_get_request")
-        a_specifier = a_request_message.specifier.to_string()
-        if (a_specifier):
-            logger.debug("has specifier")
-            try:
-                logger.debug(f"specifier is: {a_specifier}")
-                an_attribute = getattr(self, a_specifier)
-                logger.debug(f"attribute '{a_specifier}' value is [{an_attribute}]")
-                the_node = scarab.ParamNode()
-                the_node.add("values", scarab.ParamArray())
-                the_node["values"].push_back(scarab.ParamValue(an_attribute))
-                return a_request_message.reply(payload=the_node)
-            except AttributeError as this_error:
-                raise ThrowReply('service_error_invalid_specifier',
-                                 f"endpoint {self.name} has no attribute {a_specifier}, unable to get")
-        else:
-            logger.debug('no specifier')
-            the_value = self.on_get()
-            return a_request_message.reply(payload=self.result_to_scarab_payload(the_value))
+        return RequestHandler.do_get_request(self, a_request_message)
 
     def do_set_request(self, a_request_message):
-        a_specifier =  a_request_message.specifier.to_string()
-        try:
-            new_value = a_request_message.payload["values"][0]()
-        except Exception as err:
-            raise ThrowReply('service_error_bad_payload', f'Set called with invalid values: {err}')
-        new_value = getattr(new_value, "as_"+new_value.type())()
-        logger.debug(f'new_value is [{new_value}]')
-        if ( a_specifier ):
-            if not hasattr(self, a_specifier):
-                raise ThrowReply('service_error_invalid_specifier',
-                                 "endpoint {} has no attribute {}, unable to set".format(self.name, a_specifier))
-            setattr(self, a_specifier, new_value)
-            return a_request_message.reply()
-        else:
-            result = self.on_set(new_value)
-            return a_request_message.reply(payload=self.result_to_scarab_payload(result))
-
-    def do_cmd_request(self, a_request_message):
-        # Note: any command executed in this way must return a python data structure which is
-        #       able to be converted to a Param object (to be returned in the reply message)
-        method_name = a_request_message.specifier.to_string()
-        try:
-            method_ref = getattr(self, method_name)
-        except AttributeError as e:
-            raise ThrowReply('service_error_invalid_method',
-                             "error getting command's corresponding method: {}".format(str(e)))
-        the_kwargs = a_request_message.payload.to_python()
-        the_args = the_kwargs.pop('values', [])
-        try:
-            result = method_ref(*the_args, **the_kwargs)
-        except TypeError as e:
-            raise ThrowReply('service_error_invalid_value', 
-                             f'A TypeError occurred while calling the requested method for endpoint {self.name}: {method_name}. Values provided may be invalid.\nOriginal error: {str(e)}')
-        return a_request_message.reply(payload=self.result_to_scarab_payload(result))
-
-    def on_get(self):
         '''
-        placeholder method for getting the value of an endpoint.
-        Implementations may override to enable OP_GET operations.
-        The implementation must return a value which is able to be passed to the ParamValue constructor.
+        Default function for handling an OP_SET request message addressed to this endpoint.
+
+        .. note: For dripline extension developers -- This function, as defined in RequestHandler, implements the characteristic 
+        dripline-python behavior for an endpoint receiving a set request, including using the specifier to access attributes, 
+        and calling on_set() when there is no specifier.  
+        As an extension author you might typically override RequestReciever.on_set(), but leave this function alone.
+
+        .. note: For core dripline developers -- This function has to be here to correctly receive trampolined calls from 
+        the C++ base class.  It intentionally just calls the version of do_set_request() in RequestHandler.
+
+        Args:
+            a_request_message (MsgRequest): the message receveived by this endpoint
         '''
-        raise ThrowReply('service_error_invalid_method', "{} does not implement on_get".format(self.__class__))
 
-    def on_set(self, _value):
+        return RequestHandler.do_set_request(self, a_request_message)
+
+    def do_cmd_request(self, a_request_message):
         '''
-        placeholder method for setting the value of an endpoint.
-        Implementations may override to enable OP_SET operations.
-        Any returned object must already be a scarab::Param object
+        Default function for handling an OP_CMD request message addressed to this endpoint.
+
+        .. note: For dripline extension developers -- This function, as defined in RequestHandler, implements the characteristic 
+        dripline-python behavior for an endpoint receiving a cmd request, namesly using the specifier to call endpoint methods.
+
+        .. note: For core dripline developers -- This function has to be here to correctly receive trampolined calls from 
+        the C++ base class.  It intentionally just calls the version of do_cmd_request() in RequestHandler.
+
+        Args:
+            a_request_message (MsgRequest): the message receveived by this endpoint
         '''
-        raise ThrowReply('service_error_invalid_method', "{} does not implement on_set".format(self.__class__))
+
+        return RequestHandler.do_cmd_request(self, a_request_message)