PIOT-CDA-08-004: Update CoapServerAdapter and DeviceDataManager to register all required resource handlers

[labbenchstudios]

Description

• Update CoapServerAdapter to support the addition of either internally created resource handler instances, or externally created resource handlers that are passed into the server from - for example - DeviceDataManager.
  • NOTE: These instructions make use of two different CoAP libraries:
  • The CoAPthon3 open source CoAP library, located at: CoAPthon3. Reference: G.Tanganelli, C. Vallati, E.Mingozzi, "CoAPthon: Easy Development of CoAP-based IoT Applications with Python", IEEE World Forum on Internet of Things (WF-IoT 2015).
  • The aiocoap open source CoAP library, located at: aiocoap. Reference: Amsüss, Christian and Wasilak, Maciej. aiocoap: Python CoAP Library. Energy Harvesting Solutions, 2013–. http://github.com/chrysn/aiocoap/.

Review the README

• Please see README.md for further information on, and use of, this content.
• License for embedded documentation and source codes: PIOT-DOC-LIC

Estimated effort may vary greatly

• The estimated level of effort for this exercise shown in the 'Estimate' section below is a very rough approximation. The actual level of effort may vary greatly depending on your development and test environment, experience with the requisite technologies, and many other factors.

IMPORTANT NOTE

• The aiocoap specific code samples provided below within this exercise have only been tested on full Ubuntu 21.10 installations - they are not expected to work in non-Linux environments. You'll also need to use pip to install LinkHeader to retrieve resource discovery results.
  • One way to install LinkHeader using pip is as follows (your environment may require a slightly different command):

    pip install LinkHeader

Actions - for CoapServerAdapter

• From PIOT-CDA-08-001, select the initialization option most relevant for your needs. In the examples below, you can use the addResource() method as well as the _initServer() method to create and register the resource handlers you created earlier.
• From the constructor, call the self._initServer() method after initializing the CoAP server instance and storing the class-scoped dataMsgListener reference.
  • NOTE: Although you'll likely only need one approach for creating and registering resource handlers, you may want to add both, as indicated in the following actions.
• Implement the self._initServer() method. This will instance all requisite resource handlers, set appropriate callbacks (so the handlers will either (a) be notified when new data is available or (b) have access to IDataMessageListener to send updates). Here are some notional examples - remember that your implementation will likely vary from the following, and will depend on the library you choose to use:

Using aiocoap (NOTE: only tested on Ubuntu 21.10)

def _initServer(self):
    try:
        # Resource tree creation - lib-specific (this next line of code assumes use of aiocoap)
        self.rootResource = resource.Site()

        self.rootResource.add_resource( \
            ['.well-known', 'core'], \
            resource.WKCResource(self.rootResource.get_resources_as_linkheader))

        self.addResource( \
            resourcePath = ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE, \
            endName = ConfigConst.HUMIDIFIER_ACTUATOR_NAME, \
            resource = UpdateActuatorResourceHandler(dataMsgListener = self.dataMsgListener))

        # TODO: add other actuator resource handlers (for HVAC, etc.)

        sysPerfDataListener = GetSystemPerformanceResourceHandler()

        self.addResource( \
            resourcePath = ResourceNameEnum.CDA_SYSTEM_PERF_MSG_RESOURCE, \
            resource = sysPerfDataListener)

        # TODO: add other telemetry resource handlers (for SensorData)

        # register the callbacks with the data message listener instance
        self.dataMsgListener.setSystemPerformanceDataListener(listener = sysPerfDataListener)

        logging.info("Created CoAP server with default resources.")
    except Exception as e:
        traceback.print_exception(type(e), e, e.__traceback__)
        logging.warning("Failed to create CoAP server.")

Using CoAPthon3

def _initServer(self):
    try:
        self.coapServer = CoAP(server_address = (self.host, self.port))

        self.addResource( \
            resourcePath = ResourceNameEnum.CDA_ACTUATOR_CMD_RESOURCE, \
            endName = ConfigConst.HUMIDIFIER_ACTUATOR_NAME, \
            resource = UpdateActuatorResourceHandler(dataMsgListener = self.dataMsgListener))

        # TODO: add other actuator resource handlers (for HVAC, etc.)

        sysPerfDataListener = GetSystemPerformanceResourceHandler()

        self.addResource( \
            resourcePath = ResourceNameEnum.CDA_SYSTEM_PERF_MSG_RESOURCE, \
            resource = sysPerfDataListener)

        # TODO: add other telemetry resource handlers (for SensorData)

        # TODO: register the callbacks with the data message listener instance

        logging.info("Created CoAP server with default resources.")
    except Exception as e:
        traceback.print_exception(type(e), e, e.__traceback__)
        logging.warning("Failed to create CoAP server.")

• Implement the logic for the addResource(ResourceNameEnum resourceType, Resource resource) method, which will allow you to add resource handlers from external class instances (such as DeviceDataManager).

Using aiocoap

def addResource(self, resourcePath: ResourceNameEnum = None, endName: str = None, resource = None):
    if resourcePath and resource:
        uriPath = resourcePath.value

        if endName:
            uriPath = uriPath + '/' + endName

        resourceList = uriPath.split('/')

        if not self.rootResource:
            self.rootResource = resource.Site()

        self.rootResource.add_resource(resourceList, resource)
    else:
        logging.warning("No resource provided for path: " + uriPath)

Using CoAPthon3

def addResource(self, resourcePath: ResourceNameEnum = None, endName: str = None, resource = None):
    if resourcePath and resource:
        uriPath = resourcePath.value

        if endName:
            uriPath = uriPath + '/' + endName
            resource.name = endName

        trimmedUriPath   = uriPath.strip("/")
        resourceList     = trimmedUriPath.split("/")
        resourceTree     = None
        registrationPath = ""
        generationCount  = 0

        for resourceName in resourceList:
            generationCount = generationCount + 1
            registrationPath = registrationPath + "/" + resourceName

            try:
                resourceTree = self.coapServer.root[registrationPath]
            except KeyError:
                resourceTree = None

        if not resourceTree:
            if len(resourceList) != generationCount:
                return None

            resource.path = registrationPath
            self.coapServer.root[registrationPath] = resource
    else:
        logging.warning("No resource provided for path: " + str(resourcePath.value))

• NOTE: Keep in mind that resources follow a composite structure that represents a tree, so the name "PIOT/ConstrainedDevice/ActuatorCmd" is really three different resources, with the first having the name "PIOT", the next generation named "ConstrainedDevice", and the final generation named "ActuatorCmd". Fortunately, the example above handles this within the library itself.

Estimate (Small = < 2 hrs; Medium = 4 hrs; Large = 8 hrs)

• Large

Tests

• Here's where you finally get to implement your own integration test. You'll essentially start your newly created CoAP server and run a couple of quick tests - including a discovery of all resources it hosts.
• Create a new integration test in programmingtheiot/part03/integration/connection named CoapServerAdapterTest.
  • NOTE: You may want to model it after CoapClientToServerConnectorTest, although it's easiest to simply create a single test method that contains the server creation, start, and stop calls.
  • Create the server instance and start it up
  • Create a simple client using the module's test client and the URL to your server
  • Run a discovery and log the output
  • Execute a GET request using one of the resource names already registered in the server
  • Sleep for a few minutes, then stop the server

[Gau17]

Dear Professor Andy,

I discovered an issue in the premade CoapServerAdapterTest given to us as part of the initial codebase.

Line 204 in coapServerAdapterTest is sysPerfData.setMemoryUtilization(sysPerfData) This is causing a recursion issue (can be seen when line 207 is uncommented) when the to_string method is called because the object is directly passed to the method as the memory utilization rather than an actual value.

I think it might be a typo and that the intent was for the code to be this: sysPerfData.setMemoryUtilization(sysPerfVal)

Request you to recheck and update the test case.

Thanks, Gautam

[labbenchstudios]

Good catch. This is now fixed / pushed to the GitHub repo.